<s> """<STR_LIT>""" <EOL> from __future__ import absolute_import , division , print_function , with_statement <EOL> import collections <EOL> import functools <EOL> import itertools <EOL> import os <EOL> import sys <EOL> import textwrap <EOL> import types <EOL> from tornado . concurrent import Future , TracebackFuture , is_future , chain_future <EOL> from tornado . ioloop import IOLoop <EOL> from tornado . log import app_log <EOL> from tornado import stack_context <EOL> from tornado . util import PY3 , raise_exc_info <EOL> try : <EOL> try : <EOL> from functools import singledispatch <EOL> except ImportError : <EOL> from singledispatch import singledispatch <EOL> except ImportError : <EOL> if '<STR_LIT>' not in os . environ : <EOL> raise <EOL> singledispatch = None <EOL> try : <EOL> try : <EOL> from collections . abc import Generator as GeneratorType <EOL> except ImportError : <EOL> from backports_abc import Generator as GeneratorType <EOL> try : <EOL> from inspect import isawaitable <EOL> except ImportError : <EOL> from backports_abc import isawaitable <EOL> except ImportError : <EOL> if '<STR_LIT>' not in os . environ : <EOL> raise <EOL> from types import GeneratorType <EOL> def isawaitable ( x ) : <EOL> return False <EOL> if PY3 : <EOL> import builtins <EOL> else : <EOL> import __builtin__ as builtins <EOL> class KeyReuseError ( Exception ) : <EOL> pass <EOL> class UnknownKeyError ( Exception ) : <EOL> pass <EOL> class LeakedCallbackError ( Exception ) : <EOL> pass <EOL> class BadYieldError ( Exception ) : <EOL> pass <EOL> class ReturnValueIgnoredError ( Exception ) : <EOL> pass <EOL> class TimeoutError ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def _value_from_stopiteration ( e ) : <EOL> try : <EOL> return e . value <EOL> except AttributeError : <EOL> pass <EOL> try : <EOL> return e . args [ <NUM_LIT:0> ] <EOL> except ( AttributeError , IndexError ) : <EOL> return None <EOL> def engine ( func ) : <EOL> """<STR_LIT>""" <EOL> func = _make_coroutine_wrapper ( func , replace_callback = False ) <EOL> @ functools . wraps ( func ) <EOL> def wrapper ( * args , ** kwargs ) : <EOL> future = func ( * args , ** kwargs ) <EOL> def final_callback ( future ) : <EOL> if future . result ( ) is not None : <EOL> raise ReturnValueIgnoredError ( <EOL> "<STR_LIT>" % <EOL> ( future . result ( ) , ) ) <EOL> future . add_done_callback ( stack_context . wrap ( final_callback ) ) <EOL> return wrapper <EOL> def coroutine ( func , replace_callback = True ) : <EOL> """<STR_LIT>""" <EOL> return _make_coroutine_wrapper ( func , replace_callback = True ) <EOL> def _make_coroutine_wrapper ( func , replace_callback ) : <EOL> """<STR_LIT>""" <EOL> if hasattr ( types , '<STR_LIT>' ) : <EOL> func = types . coroutine ( func ) <EOL> @ functools . wraps ( func ) <EOL> def wrapper ( * args , ** kwargs ) : <EOL> future = TracebackFuture ( ) <EOL> if replace_callback and '<STR_LIT>' in kwargs : <EOL> callback = kwargs . pop ( '<STR_LIT>' ) <EOL> IOLoop . current ( ) . add_future ( <EOL> future , lambda future : callback ( future . result ( ) ) ) <EOL> try : <EOL> result = func ( * args , ** kwargs ) <EOL> except ( Return , StopIteration ) as e : <EOL> result = _value_from_stopiteration ( e ) <EOL> except Exception : <EOL> future . set_exc_info ( sys . exc_info ( ) ) <EOL> return future <EOL> else : <EOL> if isinstance ( result , GeneratorType ) : <EOL> try : <EOL> orig_stack_contexts = stack_context . _state . contexts <EOL> yielded = next ( result ) <EOL> if stack_context . _state . contexts is not orig_stack_contexts : <EOL> yielded = TracebackFuture ( ) <EOL> yielded . set_exception ( <EOL> stack_context . StackContextInconsistentError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) ) <EOL> except ( StopIteration , Return ) as e : <EOL> future . set_result ( _value_from_stopiteration ( e ) ) <EOL> except Exception : <EOL> future . set_exc_info ( sys . exc_info ( ) ) <EOL> else : <EOL> Runner ( result , future , yielded ) <EOL> try : <EOL> return future <EOL> finally : <EOL> future = None <EOL> future . set_result ( result ) <EOL> return future <EOL> return wrapper <EOL> class Return ( Exception ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , value = None ) : <EOL> super ( Return , self ) . __init__ ( ) <EOL> self . value = value <EOL> self . args = ( value , ) <EOL> class WaitIterator ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , * args , ** kwargs ) : <EOL> if args and kwargs : <EOL> raise ValueError ( <EOL> "<STR_LIT>" ) <EOL> if kwargs : <EOL> self . _unfinished = dict ( ( f , k ) for ( k , f ) in kwargs . items ( ) ) <EOL> futures = list ( kwargs . values ( ) ) <EOL> else : <EOL> self . _unfinished = dict ( ( f , i ) for ( i , f ) in enumerate ( args ) ) <EOL> futures = args <EOL> self . _finished = collections . deque ( ) <EOL> self . current_index = self . current_future = None <EOL> self . _running_future = None <EOL> for future in futures : <EOL> future . add_done_callback ( self . _done_callback ) <EOL> def done ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . _finished or self . _unfinished : <EOL> return False <EOL> self . current_index = self . current_future = None <EOL> return True <EOL> def next ( self ) : <EOL> """<STR_LIT>""" <EOL> self . _running_future = TracebackFuture ( ) <EOL> if self . _finished : <EOL> self . _return_result ( self . _finished . popleft ( ) ) <EOL> return self . _running_future <EOL> def _done_callback ( self , done ) : <EOL> if self . _running_future and not self . _running_future . done ( ) : <EOL> self . _return_result ( done ) <EOL> else : <EOL> self . _finished . append ( done ) <EOL> def _return_result ( self , done ) : <EOL> """<STR_LIT>""" <EOL> chain_future ( done , self . _running_future ) <EOL> self . current_future = done <EOL> self . current_index = self . _unfinished . pop ( done ) <EOL> @ coroutine <EOL> def __aiter__ ( self ) : <EOL> raise Return ( self ) <EOL> def __anext__ ( self ) : <EOL> if self . done ( ) : <EOL> raise getattr ( builtins , '<STR_LIT>' ) ( ) <EOL> return self . next ( ) <EOL> class YieldPoint ( object ) : <EOL> """<STR_LIT>""" <EOL> def start ( self , runner ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> def is_ready ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> def get_result ( self ) : <EOL> """<STR_LIT>""" <EOL> raise NotImplementedError ( ) <EOL> class Callback ( YieldPoint ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , key ) : <EOL> self . key = key <EOL> def start ( self , runner ) : <EOL> self . runner = runner <EOL> runner . register_callback ( self . key ) <EOL> def is_ready ( self ) : <EOL> return True <EOL> def get_result ( self ) : <EOL> return self . runner . result_callback ( self . key ) <EOL> class Wait ( YieldPoint ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , key ) : <EOL> self . key = key <EOL> def start ( self , runner ) : <EOL> self . runner = runner <EOL> def is_ready ( self ) : <EOL> return self . runner . is_ready ( self . key ) <EOL> def get_result ( self ) : <EOL> return self . runner . pop_result ( self . key ) <EOL> class WaitAll ( YieldPoint ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , keys ) : <EOL> self . keys = keys <EOL> def start ( self , runner ) : <EOL> self . runner = runner <EOL> def is_ready ( self ) : <EOL> return all ( self . runner . is_ready ( key ) for key in self . keys ) <EOL> def get_result ( self ) : <EOL> return [ self . runner . pop_result ( key ) for key in self . keys ] <EOL> def Task ( func , * args , ** kwargs ) : <EOL> """<STR_LIT>""" <EOL> future = Future ( ) <EOL> def handle_exception ( typ , value , tb ) : <EOL> if future . done ( ) : <EOL> return False <EOL> future . set_exc_info ( ( typ , value , tb ) ) <EOL> return True <EOL> def set_result ( result ) : <EOL> if future . done ( ) : <EOL> return <EOL> future . set_result ( result ) <EOL> with stack_context . ExceptionStackContext ( handle_exception ) : <EOL> func ( * args , callback = _argument_adapter ( set_result ) , ** kwargs ) <EOL> return future <EOL> class YieldFuture ( YieldPoint ) : <EOL> def __init__ ( self , future , io_loop = None ) : <EOL> """<STR_LIT>""" <EOL> self . future = future <EOL> self . io_loop = io_loop or IOLoop . current ( ) <EOL> def start ( self , runner ) : <EOL> if not self . future . done ( ) : <EOL> self . runner = runner <EOL> self . key = object ( ) <EOL> runner . register_callback ( self . key ) <EOL> self . io_loop . add_future ( self . future , runner . result_callback ( self . key ) ) <EOL> else : <EOL> self . runner = None <EOL> self . result_fn = self . future . result <EOL> def is_ready ( self ) : <EOL> if self . runner is not None : <EOL> return self . runner . is_ready ( self . key ) <EOL> else : <EOL> return True <EOL> def get_result ( self ) : <EOL> if self . runner is not None : <EOL> return self . runner . pop_result ( self . key ) . result ( ) <EOL> else : <EOL> return self . result_fn ( ) <EOL> def _contains_yieldpoint ( children ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( children , dict ) : <EOL> return any ( isinstance ( i , YieldPoint ) for i in children . values ( ) ) <EOL> if isinstance ( children , list ) : <EOL> return any ( isinstance ( i , YieldPoint ) for i in children ) <EOL> return False <EOL> def multi ( children , quiet_exceptions = ( ) ) : <EOL> """<STR_LIT>""" <EOL> if _contains_yieldpoint ( children ) : <EOL> return MultiYieldPoint ( children , quiet_exceptions = quiet_exceptions ) <EOL> else : <EOL> return multi_future ( children , quiet_exceptions = quiet_exceptions ) <EOL> Multi = multi <EOL> class MultiYieldPoint ( YieldPoint ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , children , quiet_exceptions = ( ) ) : <EOL> self . keys = None <EOL> if isinstance ( children , dict ) : <EOL> self . keys = list ( children . keys ( ) ) <EOL> children = children . values ( ) <EOL> self . children = [ ] <EOL> for i in children : <EOL> if not isinstance ( i , YieldPoint ) : <EOL> i = convert_yielded ( i ) <EOL> if is_future ( i ) : <EOL> i = YieldFuture ( i ) <EOL> self . children . append ( i ) <EOL> assert all ( isinstance ( i , YieldPoint ) for i in self . children ) <EOL> self . unfinished_children = set ( self . children ) <EOL> self . quiet_exceptions = quiet_exceptions <EOL> def start ( self , runner ) : <EOL> for i in self . children : <EOL> i . start ( runner ) <EOL> def is_ready ( self ) : <EOL> finished = list ( itertools . takewhile ( <EOL> lambda i : i . is_ready ( ) , self . unfinished_children ) ) <EOL> self . unfinished_children . difference_update ( finished ) <EOL> return not self . unfinished_children <EOL> def get_result ( self ) : <EOL> result_list = [ ] <EOL> exc_info = None <EOL> for f in self . children : <EOL> try : <EOL> result_list . append ( f . get_result ( ) ) <EOL> except Exception as e : <EOL> if exc_info is None : <EOL> exc_info = sys . exc_info ( ) <EOL> else : <EOL> if not isinstance ( e , self . quiet_exceptions ) : <EOL> app_log . error ( "<STR_LIT>" , <EOL> exc_info = True ) <EOL> if exc_info is not None : <EOL> raise_exc_info ( exc_info ) <EOL> if self . keys is not None : <EOL> return dict ( zip ( self . keys , result_list ) ) <EOL> else : <EOL> return list ( result_list ) <EOL> def multi_future ( children , quiet_exceptions = ( ) ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( children , dict ) : <EOL> keys = list ( children . keys ( ) ) <EOL> children = children . values ( ) <EOL> else : <EOL> keys = None <EOL> children = list ( map ( convert_yielded , children ) ) <EOL> assert all ( is_future ( i ) for i in children ) <EOL> unfinished_children = set ( children ) <EOL> future = Future ( ) <EOL> if not children : <EOL> future . set_result ( { } if keys is not None else [ ] ) <EOL> def callback ( f ) : <EOL> unfinished_children . remove ( f ) <EOL> if not unfinished_children : <EOL> result_list = [ ] <EOL> for f in children : <EOL> try : <EOL> result_list . append ( f . result ( ) ) <EOL> except Exception as e : <EOL> if future . done ( ) : <EOL> if not isinstance ( e , quiet_exceptions ) : <EOL> app_log . error ( "<STR_LIT>" , <EOL> exc_info = True ) <EOL> else : <EOL> future . set_exc_info ( sys . exc_info ( ) ) <EOL> if not future . done ( ) : <EOL> if keys is not None : <EOL> future . set_result ( dict ( zip ( keys , result_list ) ) ) <EOL> else : <EOL> future . set_result ( result_list ) <EOL> listening = set ( ) <EOL> for f in children : <EOL> if f not in listening : <EOL> listening . add ( f ) <EOL> f . add_done_callback ( callback ) <EOL> return future <EOL> def maybe_future ( x ) : <EOL> """<STR_LIT>""" <EOL> if is_future ( x ) : <EOL> return x <EOL> else : <EOL> fut = Future ( ) <EOL> fut . set_result ( x ) <EOL> return fut <EOL> def with_timeout ( timeout , future , io_loop = None , quiet_exceptions = ( ) ) : <EOL> """<STR_LIT>""" <EOL> result = Future ( ) <EOL> chain_future ( future , result ) <EOL> if io_loop is None : <EOL> io_loop = IOLoop . current ( ) <EOL> def error_callback ( future ) : <EOL> try : <EOL> future . result ( ) <EOL> except Exception as e : <EOL> if not isinstance ( e , quiet_exceptions ) : <EOL> app_log . error ( "<STR_LIT>" , <EOL> future , exc_info = True ) <EOL> def timeout_callback ( ) : <EOL> result . set_exception ( TimeoutError ( "<STR_LIT>" ) ) <EOL> future . add_done_callback ( error_callback ) <EOL> timeout_handle = io_loop . add_timeout ( <EOL> timeout , timeout_callback ) <EOL> if isinstance ( future , Future ) : <EOL> future . add_done_callback ( <EOL> lambda future : io_loop . remove_timeout ( timeout_handle ) ) <EOL> else : <EOL> io_loop . add_future ( <EOL> future , lambda future : io_loop . remove_timeout ( timeout_handle ) ) <EOL> return result <EOL> def sleep ( duration ) : <EOL> """<STR_LIT>""" <EOL> f = Future ( ) <EOL> IOLoop . current ( ) . call_later ( duration , lambda : f . set_result ( None ) ) <EOL> return f <EOL> _null_future = Future ( ) <EOL> _null_future . set_result ( None ) <EOL> moment = Future ( ) <EOL> moment . __doc__ = """<STR_LIT>""" <EOL> moment . set_result ( None ) <EOL> class Runner ( object ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( self , gen , result_future , first_yielded ) : <EOL> self . gen = gen <EOL> self . result_future = result_future <EOL> self . future = _null_future <EOL> self . yield_point = None <EOL> self . pending_callbacks = None <EOL> self . results = None <EOL> self . running = False <EOL> self . finished = False <EOL> self . had_exception = False <EOL> self . io_loop = IOLoop . current ( ) <EOL> self . stack_context_deactivate = None <EOL> if self . handle_yield ( first_yielded ) : <EOL> self . run ( ) <EOL> def register_callback ( self , key ) : <EOL> """<STR_LIT>""" <EOL> if self . pending_callbacks is None : <EOL> self . pending_callbacks = set ( ) <EOL> self . results = { } <EOL> if key in self . pending_callbacks : <EOL> raise KeyReuseError ( "<STR_LIT>" % ( key , ) ) <EOL> self . pending_callbacks . add ( key ) <EOL> def is_ready ( self , key ) : <EOL> """<STR_LIT>""" <EOL> if self . pending_callbacks is None or key not in self . pending_callbacks : <EOL> raise UnknownKeyError ( "<STR_LIT>" % ( key , ) ) <EOL> return key in self . results <EOL> def set_result ( self , key , result ) : <EOL> """<STR_LIT>""" <EOL> self . results [ key ] = result <EOL> if self . yield_point is not None and self . yield_point . is_ready ( ) : <EOL> try : <EOL> self . future . set_result ( self . yield_point . get_result ( ) ) <EOL> except : <EOL> self . future . set_exc_info ( sys . exc_info ( ) ) <EOL> self . yield_point = None <EOL> self . run ( ) <EOL> def pop_result ( self , key ) : <EOL> """<STR_LIT>""" <EOL> self . pending_callbacks . remove ( key ) <EOL> return self . results . pop ( key ) <EOL> def run ( self ) : <EOL> """<STR_LIT>""" <EOL> if self . running or self . finished : <EOL> return <EOL> try : <EOL> self . running = True <EOL> while True : <EOL> future = self . future <EOL> if not future . done ( ) : <EOL> return <EOL> self . future = None <EOL> try : <EOL> orig_stack_contexts = stack_context . _state . contexts <EOL> exc_info = None <EOL> try : <EOL> value = future . result ( ) <EOL> except Exception : <EOL> self . had_exception = True <EOL> exc_info = sys . exc_info ( ) <EOL> if exc_info is not None : <EOL> yielded = self . gen . throw ( * exc_info ) <EOL> exc_info = None <EOL> else : <EOL> yielded = self . gen . send ( value ) <EOL> if stack_context . _state . contexts is not orig_stack_contexts : <EOL> self . gen . throw ( <EOL> stack_context . StackContextInconsistentError ( <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) ) <EOL> except ( StopIteration , Return ) as e : <EOL> self . finished = True <EOL> self . future = _null_future <EOL> if self . pending_callbacks and not self . had_exception : <EOL> raise LeakedCallbackError ( <EOL> "<STR_LIT>" % <EOL> self . pending_callbacks ) <EOL> self . result_future . set_result ( _value_from_stopiteration ( e ) ) <EOL> self . result_future = None <EOL> self . _deactivate_stack_context ( ) <EOL> return <EOL> except Exception : <EOL> self . finished = True <EOL> self . future = _null_future <EOL> self . result_future . set_exc_info ( sys . exc_info ( ) ) <EOL> self . result_future = None <EOL> self . _deactivate_stack_context ( ) <EOL> return <EOL> if not self . handle_yield ( yielded ) : <EOL> return <EOL> finally : <EOL> self . running = False <EOL> def handle_yield ( self , yielded ) : <EOL> if _contains_yieldpoint ( yielded ) : <EOL> yielded = multi ( yielded ) <EOL> if isinstance ( yielded , YieldPoint ) : <EOL> self . future = TracebackFuture ( ) <EOL> def start_yield_point ( ) : <EOL> try : <EOL> yielded . start ( self ) <EOL> if yielded . is_ready ( ) : <EOL> self . future . set_result ( <EOL> yielded . get_result ( ) ) <EOL> else : <EOL> self . yield_point = yielded <EOL> except Exception : <EOL> self . future = TracebackFuture ( ) <EOL> self . future . set_exc_info ( sys . exc_info ( ) ) <EOL> if self . stack_context_deactivate is None : <EOL> with stack_context . ExceptionStackContext ( <EOL> self . handle_exception ) as deactivate : <EOL> self . stack_context_deactivate = deactivate <EOL> def cb ( ) : <EOL> start_yield_point ( ) <EOL> self . run ( ) <EOL> self . io_loop . add_callback ( cb ) <EOL> return False <EOL> else : <EOL> start_yield_point ( ) <EOL> else : <EOL> try : <EOL> self . future = convert_yielded ( yielded ) <EOL> except BadYieldError : <EOL> self . future = TracebackFuture ( ) <EOL> self . future . set_exc_info ( sys . exc_info ( ) ) <EOL> if not self . future . done ( ) or self . future is moment : <EOL> self . io_loop . add_future ( <EOL> self . future , lambda f : self . run ( ) ) <EOL> return False <EOL> return True <EOL> def result_callback ( self , key ) : <EOL> return stack_context . wrap ( _argument_adapter ( <EOL> functools . partial ( self . set_result , key ) ) ) <EOL> def handle_exception ( self , typ , value , tb ) : <EOL> if not self . running and not self . finished : <EOL> self . future = TracebackFuture ( ) <EOL> self . future . set_exc_info ( ( typ , value , tb ) ) <EOL> self . run ( ) <EOL> return True <EOL> else : <EOL> return False <EOL> def _deactivate_stack_context ( self ) : <EOL> if self . stack_context_deactivate is not None : <EOL> self . stack_context_deactivate ( ) <EOL> self . stack_context_deactivate = None <EOL> Arguments = collections . namedtuple ( '<STR_LIT>' , [ '<STR_LIT:args>' , '<STR_LIT>' ] ) <EOL> def _argument_adapter ( callback ) : <EOL> """<STR_LIT>""" <EOL> def wrapper ( * args , ** kwargs ) : <EOL> if kwargs or len ( args ) > <NUM_LIT:1> : <EOL> callback ( Arguments ( args , kwargs ) ) <EOL> elif args : <EOL> callback ( args [ <NUM_LIT:0> ] ) <EOL> else : <EOL> callback ( None ) <EOL> return wrapper <EOL> if sys . version_info >= ( <NUM_LIT:3> , <NUM_LIT:3> ) : <EOL> exec ( textwrap . dedent ( """<STR_LIT>""" ) ) <EOL> else : <EOL> @ coroutine <EOL> def _wrap_awaitable ( x ) : <EOL> if hasattr ( x , '<STR_LIT>' ) : <EOL> _i = x . __await__ ( ) <EOL> else : <EOL> _i = iter ( x ) <EOL> try : <EOL> _y = next ( _i ) <EOL> except StopIteration as _e : <EOL> _r = _value_from_stopiteration ( _e ) <EOL> else : <EOL> while <NUM_LIT:1> : <EOL> try : <EOL> _s = yield _y <EOL> except GeneratorExit as _e : <EOL> try : <EOL> _m = _i . close <EOL> except AttributeError : <EOL> pass <EOL> else : <EOL> _m ( ) <EOL> raise _e <EOL> except BaseException as _e : <EOL> _x = sys . exc_info ( ) <EOL> try : <EOL> _m = _i . throw <EOL> except AttributeError : <EOL> raise _e <EOL> else : <EOL> try : <EOL> _y = _m ( * _x ) <EOL> except StopIteration as _e : <EOL> _r = _value_from_stopiteration ( _e ) <EOL> break <EOL> else : <EOL> try : <EOL> if _s is None : <EOL> _y = next ( _i ) <EOL> else : <EOL> _y = _i . send ( _s ) <EOL> except StopIteration as _e : <EOL> _r = _value_from_stopiteration ( _e ) <EOL> break <EOL> raise Return ( _r ) <EOL> def convert_yielded ( yielded ) : <EOL> """<STR_LIT>""" <EOL> if isinstance ( yielded , ( list , dict ) ) : <EOL> return multi ( yielded ) <EOL> elif is_future ( yielded ) : <EOL> return yielded <EOL> elif isawaitable ( yielded ) : <EOL> return _wrap_awaitable ( yielded ) <EOL> else : <EOL> raise BadYieldError ( "<STR_LIT>" % ( yielded , ) ) <EOL> if singledispatch is not None : <EOL> convert_yielded = singledispatch ( convert_yielded ) <EOL> try : <EOL> import tornado . platform . asyncio <EOL> except ImportError : <EOL> pass <EOL> else : <EOL> tornado </s>
