<s> """<STR_LIT>""" <EOL> numtype = ( int , float ) <EOL> anytype = ( int , float , str ) <EOL> seqtype = ( list , tuple ) <EOL> def if_then_else ( cond = anytype , x = anytype , y = anytype ) : <EOL> if cond : <EOL> return x <EOL> else : <EOL> return y <EOL> def my_gcd ( a = numtype , b = numtype ) : <EOL> r = a % b <EOL> while r : <EOL> a = b <EOL> b = r <EOL> r = a % b <EOL> return b <EOL> def is_perfect_number ( n = int ) : <EOL> div = <NUM_LIT:1> <EOL> sum = <NUM_LIT:0> <EOL> while div < n : <EOL> if n % div == <NUM_LIT:0> : <EOL> sum += div <EOL> div += <NUM_LIT:1> <EOL> return n == sum <EOL> def my_bool ( x = int ) : <EOL> return not not x <EOL> def my_contains ( seq = seqtype , elem = anytype ) : <EOL> return elem in seq <EOL> def is_one_or_two ( n = int ) : <EOL> return n in [ <NUM_LIT:1> , <NUM_LIT:2> ] <EOL> def two_plus_two ( ) : <EOL> """<STR_LIT>""" <EOL> array = [ <NUM_LIT:0> ] * <NUM_LIT:3> <EOL> array [ <NUM_LIT:0> ] = <NUM_LIT:2> <EOL> array [ <NUM_LIT:1> ] = <NUM_LIT:2> <EOL> array [ <NUM_LIT:2> ] = array [ <NUM_LIT:0> ] + array [ <NUM_LIT:1> ] <EOL> return array [ <NUM_LIT:2> ] <EOL> def get_set_del_slice ( l = list ) : <EOL> del l [ : <NUM_LIT:1> ] <EOL> del l [ - <NUM_LIT:1> : ] <EOL> del l [ <NUM_LIT:2> : <NUM_LIT:4> ] <EOL> l [ : <NUM_LIT:1> ] = [ <NUM_LIT:3> ] <EOL> l [ - <NUM_LIT:1> : ] = [ <NUM_LIT:9> ] <EOL> l [ <NUM_LIT:2> : <NUM_LIT:4> ] = [ <NUM_LIT:8> , <NUM_LIT:11> ] <EOL> return l [ : <NUM_LIT:2> ] , l [ <NUM_LIT:5> : ] , l [ <NUM_LIT:3> : <NUM_LIT:5> ] <EOL> def sieve_of_eratosthenes ( ) : <EOL> """<STR_LIT>""" <EOL> flags = [ True ] * ( <NUM_LIT> + <NUM_LIT:1> ) <EOL> count = <NUM_LIT:0> <EOL> i = <NUM_LIT:2> <EOL> while i <= <NUM_LIT> : <EOL> if flags [ i ] : <EOL> k = i + i <EOL> while k <= <NUM_LIT> : <EOL> flags [ k ] = False <EOL> k = k + i <EOL> count = count + <NUM_LIT:1> <EOL> i = i + <NUM_LIT:1> <EOL> return count <EOL> def simple_func ( i = numtype ) : <EOL> return i + <NUM_LIT:1> <EOL> def while_func ( i = numtype ) : <EOL> total = <NUM_LIT:0> <EOL> while i > <NUM_LIT:0> : <EOL> total = total + i <EOL> i = i - <NUM_LIT:1> <EOL> return total <EOL> def nested_whiles ( i = int , j = int ) : <EOL> s = '<STR_LIT>' <EOL> z = <NUM_LIT:5> <EOL> while z > <NUM_LIT:0> : <EOL> z = z - <NUM_LIT:1> <EOL> u = i <EOL> while u < j : <EOL> u = u + <NUM_LIT:1> <EOL> s = s + '<STR_LIT:.>' <EOL> s = s + '<STR_LIT:!>' <EOL> return s <EOL> def poor_man_range ( i = int ) : <EOL> lst = [ ] <EOL> while i > <NUM_LIT:0> : <EOL> i = i - <NUM_LIT:1> <EOL> lst . append ( i ) <EOL> lst . reverse ( ) <EOL> return lst <EOL> def poor_man_rev_range ( i = int ) : <EOL> lst = [ ] <EOL> while i > <NUM_LIT:0> : <EOL> i = i - <NUM_LIT:1> <EOL> lst += [ i ] <EOL> return lst <EOL> def simple_id ( x = anytype ) : <EOL> return x <EOL> def branch_id ( cond = anytype , a = anytype , b = anytype ) : <EOL> while <NUM_LIT:1> : <EOL> if cond : <EOL> return a <EOL> else : <EOL> return b <EOL> def builtinusage ( ) : <EOL> return pow ( <NUM_LIT:2> , <NUM_LIT:2> ) <EOL> def yast ( lst = seqtype ) : <EOL> total = <NUM_LIT:0> <EOL> for z in lst : <EOL> total = total + z <EOL> return total <EOL> def time_waster ( n = int ) : <EOL> """<STR_LIT>""" <EOL> i = <NUM_LIT:0> <EOL> x = <NUM_LIT:1> <EOL> while i < n : <EOL> j = <NUM_LIT:0> <EOL> while j <= i : <EOL> j = j + <NUM_LIT:1> <EOL> x = x + ( i & j ) <EOL> i = i + <NUM_LIT:1> <EOL> return x <EOL> def half_of_n ( n = int ) : <EOL> """<STR_LIT>""" <EOL> i = <NUM_LIT:0> <EOL> lst = range ( n ) <EOL> while lst : <EOL> lst = lst [ <NUM_LIT:1> : - <NUM_LIT:1> ] <EOL> i = i + <NUM_LIT:1> <EOL> return i <EOL> def int_id ( x = int ) : <EOL> i = <NUM_LIT:0> <EOL> while i < x : <EOL> i = i + <NUM_LIT:1> <EOL> return i <EOL> def greet ( target = str ) : <EOL> """<STR_LIT>""" <EOL> hello = "<STR_LIT:hello>" <EOL> return hello + target <EOL> def choose_last ( ) : <EOL> """<STR_LIT>""" <EOL> set = [ "<STR_LIT:foo>" , "<STR_LIT:bar>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" ] <EOL> choice = "<STR_LIT>" <EOL> for choice in set : <EOL> pass <EOL> return choice <EOL> def poly_branch ( x = int ) : <EOL> if x : <EOL> y = [ <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> ] <EOL> else : <EOL> y = [ '<STR_LIT:a>' , '<STR_LIT:b>' , '<STR_LIT:c>' ] <EOL> z = y <EOL> return z * <NUM_LIT:2> <EOL> def s_and ( x = anytype , y = anytype ) : <EOL> if x and y : <EOL> return '<STR_LIT:yes>' <EOL> else : <EOL> return '<STR_LIT>' <EOL> def break_continue ( x = numtype ) : <EOL> result = [ ] <EOL> i = <NUM_LIT:0> <EOL> while <NUM_LIT:1> : <EOL> i = i + <NUM_LIT:1> <EOL> try : <EOL> if i & <NUM_LIT:1> : <EOL> continue <EOL> if i >= x : <EOL> break <EOL> finally : <EOL> result . append ( i ) <EOL> i = i + <NUM_LIT:1> <EOL> return result <EOL> def reverse_3 ( lst = seqtype ) : <EOL> try : <EOL> a , b , c = lst <EOL> except : <EOL> return <NUM_LIT:0> , <NUM_LIT:0> , <NUM_LIT:0> <EOL> return c , b , a <EOL> def finallys ( lst = seqtype ) : <EOL> x = <NUM_LIT:1> <EOL> try : <EOL> x = <NUM_LIT:2> <EOL> try : <EOL> x = <NUM_LIT:3> <EOL> a , = lst <EOL> x = <NUM_LIT:4> <EOL> except KeyError : <EOL> return <NUM_LIT:5> <EOL> except ValueError : <EOL> return <NUM_LIT:6> <EOL> b , = lst <EOL> x = <NUM_LIT:7> <EOL> finally : <EOL> x = <NUM_LIT:8> <EOL> return x <EOL> def finally2 ( o , k ) : <EOL> try : <EOL> o [ k ] += <NUM_LIT:1> <EOL> finally : <EOL> o [ - <NUM_LIT:1> ] = '<STR_LIT>' <EOL> def bare_raise ( o , ignore ) : <EOL> try : <EOL> return o [ <NUM_LIT:5> ] <EOL> except : <EOL> if not ignore : <EOL> raise <EOL> def factorial ( n = int ) : <EOL> if n <= <NUM_LIT:1> : <EOL> return <NUM_LIT:1> <EOL> else : <EOL> return n * factorial ( n - <NUM_LIT:1> ) <EOL> def factorial2 ( n = int ) : <EOL> if n > <NUM_LIT:1> : <EOL> return n * factorial2 ( n - <NUM_LIT:1> ) <EOL> else : <EOL> return <NUM_LIT:1> <EOL> def _append_five ( lst ) : <EOL> lst += [ <NUM_LIT:5> ] <EOL> def call_five ( ) : <EOL> a = [ ] <EOL> _append_five ( a ) <EOL> return a <EOL> def _append_six ( lst ) : <EOL> lst += [ <NUM_LIT:6> ] <EOL> def call_five_six ( ) : <EOL> a = [ ] <EOL> _append_five ( a ) <EOL> _append_six ( a ) <EOL> return a <EOL> def call_unpack_56 ( ) : <EOL> a = call_five_six ( ) <EOL> return len ( a ) , a [ <NUM_LIT:0> ] , a [ <NUM_LIT:1> ] <EOL> def forty_two ( ) : <EOL> return <NUM_LIT> <EOL> def never_called ( ) : <EOL> return "<STR_LIT>" <EOL> def constant_result ( ) : <EOL> if forty_two ( ) : <EOL> return "<STR_LIT>" <EOL> else : <EOL> return never_called ( ) <EOL> class CallablePrebuiltConstant ( object ) : <EOL> def __call__ ( self ) : <EOL> return <NUM_LIT> <EOL> callable_prebuilt_constant = CallablePrebuiltConstant ( ) <EOL> def call_cpbc ( ) : <EOL> return callable_prebuilt_constant ( ) <EOL> class E1 ( Exception ) : <EOL> pass <EOL> class E2 ( Exception ) : <EOL> pass <EOL> def raise_choose ( n ) : <EOL> if n == <NUM_LIT:1> : <EOL> raise E1 <EOL> elif n == <NUM_LIT:2> : <EOL> raise E2 <EOL> elif n == - <NUM_LIT:1> : <EOL> raise Exception <EOL> return <NUM_LIT:0> <EOL> def try_raise_choose ( n = int ) : <EOL> try : <EOL> raise_choose ( n ) <EOL> except E1 : <EOL> return <NUM_LIT:1> <EOL> except E2 : <EOL> return <NUM_LIT:2> <EOL> except Exception : <EOL> return - <NUM_LIT:1> <EOL> return <NUM_LIT:0> <EOL> def do_try_raise_choose ( ) : <EOL> r = [ ] <EOL> for n in [ - <NUM_LIT:1> , <NUM_LIT:0> , <NUM_LIT:1> , <NUM_LIT:2> ] : <EOL> r . append ( try_raise_choose ( n ) ) <EOL> return r <EOL> class C ( object ) : pass <EOL> def build_instance ( ) : <EOL> c = C ( ) <EOL> return c <EOL> def set_attr ( ) : <EOL> c = C ( ) <EOL> c . a = <NUM_LIT:1> <EOL> c . a = <NUM_LIT:2> <EOL> return c . a <EOL> def merge_setattr ( x ) : <EOL> if x : <EOL> c = C ( ) <EOL> c . a = <NUM_LIT:1> <EOL> else : <EOL> c = C ( ) <EOL> return c . a <EOL> class D ( C ) : pass <EOL> class E ( C ) : pass <EOL> def inheritance1 ( ) : <EOL> d = D ( ) <EOL> d . stuff = ( ) <EOL> e = E ( ) <EOL> e . stuff = - <NUM_LIT:12> <EOL> e . stuff = <NUM_LIT:3> <EOL> lst = [ d , e ] <EOL> return d . stuff , e . stuff <EOL> def inheritance2 ( ) : <EOL> d = D ( ) <EOL> d . stuff = ( - <NUM_LIT:12> , - <NUM_LIT:12> ) <EOL> e = E ( ) <EOL> e . stuff = ( <NUM_LIT:3> , <NUM_LIT> ) <EOL> return _getstuff ( d ) , _getstuff ( e ) <EOL> class F : <EOL> pass <EOL> class G ( F ) : <EOL> def m ( self , x ) : <EOL> return self . m2 ( x ) <EOL> def m2 ( self , x ) : <EOL> return D ( ) , x <EOL> class H ( F ) : <EOL> def m ( self , y ) : <EOL> self . attr = <NUM_LIT:1> <EOL> return E ( ) , y <EOL> def knownkeysdict ( b = anytype ) : <EOL> if b : <EOL> d = { '<STR_LIT:a>' : <NUM_LIT:0> } <EOL> d [ '<STR_LIT:b>' ] = b <EOL> d [ '<STR_LIT:c>' ] = '<STR_LIT>' <EOL> else : <EOL> d = { '<STR_LIT:b>' : - <NUM_LIT> } <EOL> return d [ '<STR_LIT:b>' ] <EOL> def generaldict ( key = str , value = int , key2 = str , value2 = int ) : <EOL> d = { key : value } <EOL> d [ key2 ] = value2 <EOL> return d [ key or key2 ] <EOL> def prime ( n = int ) : <EOL> return len ( [ i for i in range ( <NUM_LIT:1> , n + <NUM_LIT:1> ) if n % i == <NUM_LIT:0> ] ) == <NUM_LIT:2> <EOL> class A0 : <EOL> pass <EOL> class A1 ( A0 ) : <EOL> clsattr = <NUM_LIT> <EOL> class A2 ( A1 ) : <EOL> clsattr = <NUM_LIT> <EOL> class A3 ( A2 ) : <EOL> clsattr = <NUM_LIT> <EOL> class A4 ( A3 ) : <EOL> pass <EOL> class A5 ( A0 ) : <EOL> clsattr = <NUM_LIT> <EOL> def classattribute ( flag = int ) : <EOL> if flag == <NUM_LIT:1> : <EOL> x = A1 ( ) <EOL> elif flag == <NUM_LIT:2> : <EOL> x = A2 ( ) <EOL> elif flag == <NUM_LIT:3> : <EOL> x = A3 ( ) <EOL> elif flag == <NUM_LIT:4> : <EOL> x = A4 ( ) <EOL> else : <EOL> x = A5 ( ) <EOL> return x . clsattr <EOL> class Z : <EOL> def my_method ( self ) : <EOL> return self . my_attribute <EOL> class WithInit : <EOL> def __init__ ( self , n ) : <EOL> self . a = n <EOL> class WithMoreInit ( WithInit ) : <EOL> def __init__ ( self , n , m ) : <EOL> WithInit . __init__ ( self , n ) <EOL> self . b = m <EOL> def simple_method ( v = anytype ) : <EOL> z = Z ( ) <EOL> z . my_attribute = v <EOL> return z . my_method ( ) <EOL> def with_init ( v = int ) : <EOL> z = WithInit ( v ) <EOL> return z . a <EOL> def with_more_init ( v = int , w = bool ) : <EOL> z = WithMoreInit ( v , w ) <EOL> if z . b : <EOL> return z . a <EOL> else : <EOL> return - z . a <EOL> global_z = Z ( ) <EOL> global_z . my_attribute = <NUM_LIT> <EOL> def global_instance ( ) : <EOL> return global_z . my_method ( ) <EOL> def call_Z_my_method ( z ) : <EOL> return z . my_method <EOL> def somepbc_simplify ( ) : <EOL> z = Z ( ) <EOL> call_Z_my_method ( global_z ) <EOL> call_Z_my_method ( z ) <EOL> class ClassWithMethods : <EOL> def cm ( cls , x ) : <EOL> return x <EOL> cm = classmethod ( cm ) <EOL> def sm ( x ) : <EOL> return x <EOL> sm = staticmethod ( sm ) <EOL> global_c = C ( ) <EOL> global_c . a = <NUM_LIT:1> <EOL> def global_newstyle_instance ( ) : <EOL> return global_c <EOL> global_rl = [ ] <EOL> global_rl . append ( global_rl ) <EOL> def global_recursive_list ( ) : <EOL> return global_rl <EOL> class MI_A ( object ) : <EOL> a = <NUM_LIT:1> <EOL> class MI_B ( MI_A ) : <EOL> b = <NUM_LIT:2> <EOL> class MI_C ( MI_A ) : <EOL> c = <NUM_LIT:3> <EOL> class MI_D ( MI_B , MI_C ) : <EOL> d = <NUM_LIT:4> <EOL> def multiple_inheritance ( ) : <EOL> i = MI_D ( ) <EOL> return i . a + i . b + i . c + i . d <EOL> class CBase ( object ) : <EOL> pass <EOL> class CSub1 ( CBase ) : <EOL> def m ( self ) : <EOL> self . x = <NUM_LIT> <EOL> return self . x <EOL> class CSub2 ( CBase ) : <EOL> def m ( self ) : <EOL> self . x = '<STR_LIT>' <EOL> return self . x <EOL> def methodcall_is_precise ( cond ) : <EOL> if cond : <EOL> x = CSub1 ( ) <EOL> else : <EOL> x = CSub2 ( ) <EOL> x . m ( ) <EOL> return CSub1 ( ) . m ( ) <EOL> def flow_type_info ( i ) : <EOL> if isinstance ( i , int ) : <EOL> a = i + <NUM_LIT:1> <EOL> else : <EOL> a = len ( str ( i ) ) <EOL> return a <EOL> def flow_usertype_info ( ob ) : <EOL> if isinstance ( ob , WithInit ) : <EOL> return ob <EOL> else : <EOL> return WithMoreInit ( <NUM_LIT:1> , <NUM_LIT:2> ) <EOL> def flow_identity_info ( x = object , y = object ) : <EOL> if x is None : <EOL> if y is None : <EOL> return ( x , y ) <EOL> else : <EOL> return ( x , None ) <EOL> else : <EOL> if y is None : <EOL> return ( None , y ) <EOL> else : <EOL> return ( None , None ) <EOL> def star_args0 ( * args ) : <EOL> return args [ <NUM_LIT:0> ] / <NUM_LIT:2> <EOL> def call_star_args0 ( z ) : <EOL> return star_args0 ( z ) <EOL> def star_args1 ( a , * args ) : <EOL> return a + args [ <NUM_LIT:0> ] / <NUM_LIT:2> <EOL> def call_star_args1 ( z ) : <EOL> return star_args1 ( z , <NUM_LIT:20> ) <EOL> def star_args1def ( a = <NUM_LIT:4> , * args ) : <EOL> if args : <EOL> return a + args [ <NUM_LIT:0> ] / <NUM_LIT:2> <EOL> else : <EOL> return a * <NUM_LIT:3> <EOL> def call_star_args1def ( z ) : <EOL> a = star_args1def ( z , <NUM_LIT> ) <EOL> b = star_args1def ( <NUM_LIT:5> ) <EOL> c = star_args1def ( ) <EOL> return a + b + c <EOL> def star_args ( x , y , * args ) : <EOL> return x + args [ <NUM_LIT:0> ] <EOL> def call_star_args ( z ) : <EOL> return star_args ( z , <NUM_LIT:5> , <NUM_LIT:10> , <NUM_LIT:15> , <NUM_LIT:20> ) <EOL> def call_star_args_multiple ( z ) : <EOL> a = star_args ( z , <NUM_LIT:5> , <NUM_LIT:10> ) <EOL> b = star_args ( z , <NUM_LIT:5> , <NUM_LIT:10> , <NUM_LIT:15> ) <EOL> c = star_args ( z , <NUM_LIT:5> , <NUM_LIT:10> , <NUM_LIT:15> , <NUM_LIT:20> ) <EOL> return a + b + c <EOL> def default_args ( x , y = <NUM_LIT:2> , z = <NUM_LIT:3> L ) : <EOL> return x + y + z <EOL> def call_default_args ( u ) : <EOL> return default_args ( <NUM_LIT> , u ) <EOL> def default_and_star_args ( x , y = <NUM_LIT:2> , z = <NUM_LIT:3> , * more ) : <EOL> return x + y + z + len ( more ) <EOL> def call_default_and_star_args ( u ) : <EOL> return ( default_and_star_args ( <NUM_LIT> , u ) , <EOL> default_and_star_args ( - <NUM_LIT:1000> , - <NUM_LIT> , - <NUM_LIT> , - <NUM_LIT> , - <NUM_LIT> ) ) <EOL> def call_with_star ( z ) : <EOL> return default_args ( - <NUM_LIT:20> , * z ) <EOL> def call_with_keyword ( z ) : <EOL> return default_args ( - <NUM_LIT:20> , z = z ) <EOL> def call_very_complex ( z , args , kwds ) : <EOL> return default_args ( - <NUM_LIT:20> , z = z , * args , ** kwds ) <EOL> def powerset ( setsize = int ) : <EOL> """<STR_LIT>""" <EOL> set = range ( setsize ) <EOL> maxcardinality = pow ( <NUM_LIT:2> , setsize ) <EOL> bitmask = <NUM_LIT:0> L <EOL> powerset = [ None ] * maxcardinality <EOL> ptr = <NUM_LIT:0> <EOL> while bitmask < maxcardinality : <EOL> bitpos = <NUM_LIT:1> L <EOL> index = <NUM_LIT:0> <EOL> subset = [ ] <EOL> while bitpos < maxcardinality : <EOL> if bitpos & bitmask : <EOL> subset = subset + [ set [ index ] ] <EOL> index += <NUM_LIT:1> <EOL> bitpos <<= <NUM_LIT:1> <EOL> powerset [ ptr ] = subset <EOL> ptr += <NUM_LIT:1> <EOL> bitmask += <NUM_LIT:1> <EOL> return powerset <EOL> def harmonic ( n ) : <EOL> result = <NUM_LIT:0.0> <EOL> for i in range ( n , <NUM_LIT:0> , - <NUM_LIT:1> ) : <EOL> result += <NUM_LIT:1.0> / n <EOL> return result <EOL> def t_isinstance ( x , y ) : <EOL> return isinstance ( x , ( int , long ) ) and isinstance ( y , int ) <EOL> def t_issubclass ( x , y ) : <EOL> return issubclass ( type ( x ) , ( int , long ) ) and issubclass ( type ( y ) , int ) <EOL> def t_neg_long ( ) : <EOL> return - <NUM_LIT> L <EOL> def t_attrerror ( x ) : <EOL> try : <EOL> return x . foobar <EOL> except AttributeError : <EOL> return <NUM_LIT> <EOL> class Exc ( Exception ) : <EOL> def __init__ ( self , v ) : <EOL> Exception . __init__ ( self , v ) <EOL> def exception_subclass_sanity ( x ) : <EOL> try : <EOL> raise Exc ( x ) <EOL> except Exception , e : <EOL> return e . args [ <NUM_LIT:0> ] <EOL> class HaveProp ( object ) : <EOL> def __init__ ( self , v ) : <EOL> self . v = v <EOL> def _hi ( self ) : <EOL> return self . v <EOL> hi = property ( _hi , doc = "<STR_LIT>" ) <EOL> def run_prop ( v ) : <EOL> return HaveProp ( v ) . hi <EOL> def _somebug1 ( n = int ) : <EOL> l = [ ] <EOL> v = l . append <EOL> while n : <EOL> l [ <NUM_LIT:7> ] = <NUM_LIT:5> <EOL> break <EOL> return v <EOL> def _inheritance_nonrunnable ( ) : <EOL> d = D ( ) <EOL> d . stuff = ( - <NUM_LIT:12> , - <NUM_LIT:12> ) <EOL> e = E ( ) <EOL> e . stuff = ( <NUM_LIT:3> , "<STR_LIT>" ) <EOL> return C ( ) . stuff <EOL> def _getstuff ( x ) : <EOL> return x . stuff <EOL> class BadInit ( object ) : <EOL> def update ( self , k ) : <EOL> self . k = <NUM_LIT:1> <EOL> def __init__ ( self , v ) : <EOL> return <EOL> self . update ( ** { '<STR_LIT:k>' : v } ) <EOL> def read ( self ) : <EOL> return self . k <EOL> global_bi = BadInit ( <NUM_LIT:1> ) <EOL> def global_badinit ( ) : <EOL> return global_bi . read ( ) <EOL> def _attrs ( ) : <EOL> def b ( ) : pass <EOL> b . f = <NUM_LIT:4> <EOL> b . g = <NUM_LIT:5> <EOL> return b . f + b . g <EOL> def _methodcall1 ( cond ) : <EOL> if cond : <EOL> x = G ( ) <EOL> else : <EOL> x = H ( ) <EOL> return x . m ( <NUM_LIT> ) <EOL> def func1 ( ) : <EOL> pass <EOL> def func2 ( ) : <EOL> pass <EOL> def mergefunctions ( cond ) : <EOL> if cond : <EOL> x = func1 <EOL> else : <EOL> x = func2 <EOL> return x <EOL> def func_producing_exception ( ) : <EOL> raise ValueError , "<STR_LIT>" <EOL> def funccallsex ( ) : <EOL> return func_producing_exception ( ) <EOL> def func_arg_unpack ( ) : <EOL> a , b = <NUM_LIT:3> , "<STR_LIT:hello>" <EOL> return a <EOL> class APBC : <EOL> def __init__ ( self ) : <EOL> self . answer = <NUM_LIT> <EOL> apbc = APBC ( ) <EOL> apbc . answer = <NUM_LIT:7> <EOL> def preserve_pbc_attr_on_instance ( cond ) : <EOL> if cond : <EOL> x = APBC ( ) <EOL> else : <EOL> x = apbc <EOL> return x . answer <EOL> class APBCS ( object ) : <EOL> __slots__ = [ '<STR_LIT>' ] <EOL> def __init__ ( self ) : <EOL> self . answer = <NUM_LIT> <EOL> apbcs = APBCS ( ) <EOL> apbcs . answer = <NUM_LIT:7> <EOL> def preserve_pbc_attr_on_instance_with_slots ( cond ) : <EOL> if cond : <EOL> x = APBCS ( ) <EOL> else : <EOL> x = apbcs <EOL> return x . answer <EOL> def is_and_knowntype ( x ) : <EOL> if x is None : <EOL> return x <EOL> else : <EOL> return None <EOL> def isinstance_and_knowntype ( x ) : <EOL> if isinstance ( x , APBC ) : <EOL> return x <EOL> else : <EOL> return apbc <EOL> def simple_slice ( x ) : <EOL> return x [ : <NUM_LIT:10> ] <EOL> def simple_iter ( x ) : <EOL> return iter ( x ) <EOL> def simple_zip ( x , y ) : <EOL> return zip ( x , y ) <EOL> def dict_copy ( d ) : <EOL> return d . copy ( ) <EOL> def dict_update ( x ) : <EOL> d = { x : x } <EOL> d . update ( { <NUM_LIT:1> : <NUM_LIT:2> } ) <EOL> return d <EOL> def dict_keys ( ) : <EOL> d = { "<STR_LIT:a>" : <NUM_LIT:1> } <EOL> return d . keys ( ) <EOL> def dict_keys2 ( ) : <EOL> d = { "<STR_LIT:a>" : <NUM_LIT:1> } <EOL> keys = d . keys ( ) <EOL> d [ <NUM_LIT:1> ] = <NUM_LIT:12> <EOL> return keys <EOL> def dict_values ( ) : <EOL> d = { "<STR_LIT:a>" : "<STR_LIT:a>" } <EOL> return d . values ( ) <EOL> def dict_values2 ( ) : <EOL> d = { "<STR_LIT:a>" : "<STR_LIT:a>" } <EOL> values = d . values ( ) <EOL> d [ <NUM_LIT:1> ] = <NUM_LIT:12> <EOL> return values <EOL> def dict_items ( ) : <EOL> d = { '<STR_LIT:a>' : <NUM_LIT:1> } <EOL> return d . items ( ) <EOL> class Exc ( Exception ) : <EOL> pass <EOL> def exception_deduction0 ( x ) : <EOL> pass <EOL> def exception_deduction ( ) : <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:2> ) <EOL> except Exc , e : <EOL> return e <EOL> return Exc ( ) <EOL> def always_raising ( x ) : <EOL> raise ValueError <EOL> def witness ( x ) : <EOL> pass <EOL> def exception_deduction_with_raise1 ( x ) : <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:2> ) <EOL> if x : <EOL> raise Exc ( ) <EOL> except Exc , e : <EOL> witness ( e ) <EOL> return e <EOL> return Exc ( ) <EOL> def exception_deduction_with_raise2 ( x ) : <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:2> ) <EOL> if x : <EOL> raise Exc <EOL> except Exc , e : <EOL> witness ( e ) <EOL> return e <EOL> return Exc ( ) <EOL> def exception_deduction_with_raise3 ( x ) : <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:2> ) <EOL> if x : <EOL> raise Exc , Exc ( ) <EOL> except Exc , e : <EOL> witness ( e ) <EOL> return e <EOL> return Exc ( ) <EOL> def slice_union ( x ) : <EOL> if x : <EOL> return slice ( <NUM_LIT:1> ) <EOL> else : <EOL> return slice ( <NUM_LIT:0> , <NUM_LIT:10> , <NUM_LIT:2> ) <EOL> def exception_deduction_we_are_dumb ( ) : <EOL> a = <NUM_LIT:1> <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:2> ) <EOL> except Exc , e : <EOL> a += <NUM_LIT:1> <EOL> return e <EOL> return Exc ( ) <EOL> class Exc2 ( Exception ) : <EOL> pass <EOL> def nested_exception_deduction ( ) : <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:1> ) <EOL> except Exc , e : <EOL> try : <EOL> exception_deduction0 ( <NUM_LIT:2> ) <EOL> except Exc2 , f : <EOL> return ( e , f ) <EOL> return ( e , Exc2 ( ) ) <EOL> return ( Exc ( ) , Exc2 ( ) ) <EOL> class Exc3 ( Exception ) : <EOL> def m ( self ) : <EOL> return <NUM_LIT:1> <EOL> class Exc4 ( Exc3 ) : <EOL> def m ( self ) : <EOL> return <NUM_LIT:1> <EOL> class Sp : <EOL> def o ( self ) : <EOL> raise Exc3 <EOL> class Mod : <EOL> def __init__ ( self , s ) : <EOL> self . s = s <EOL> def p ( self ) : <EOL> s = self . s <EOL> try : <EOL> s . o ( ) <EOL> except Exc3 , e : <EOL> return e . m ( ) <EOL> return <NUM_LIT:0> <EOL> class Mod3 : <EOL> def __init__ ( self , s ) : <EOL> self . s = s <EOL> def p ( self ) : <EOL> s = self . s <EOL> try : <EOL> s . o ( ) <EOL> except Exc4 , e1 : <EOL> return e1 . m ( ) <EOL> except Exc3 , e2 : <EOL> try : <EOL> return e2 . m ( ) <EOL> except Exc4 , e3 : <EOL> return e3 . m ( ) <EOL> return <NUM_LIT:0> <EOL> mod = Mod ( Sp ( ) ) <EOL> mod3 = Mod3 ( Sp ( ) ) <EOL> def exc_deduction_our_exc_plus_others ( ) : <EOL> return mod . p ( ) <EOL> def exc_deduction_our_excs_plus_others ( ) : <EOL> return mod3 . p ( ) <EOL> def call_two_funcs_but_one_can_only_raise ( n ) : <EOL> fn = [ witness , always_raising ] [ n ] <EOL> return fn ( n ) <EOL> class BltinCode : <EOL> def __init__ ( self , func , framecls ) : <EOL> self . func = func <EOL> self . framecls = framecls <EOL> def call ( self , x ) : <EOL> return self . framecls ( self ) . run ( x ) <EOL> class BltinFrame : <EOL> def __init__ ( self , code ) : <EOL> self . code = code <EOL> def bltin_code_frame_f ( x ) : <EOL> return x <EOL> def bltin_code_frame_g ( x ) : <EOL> return x <EOL> class FBltinFrame ( BltinFrame ) : <EOL> def run ( self , x ) : <EOL> return self . code . func ( x ) <EOL> class GBltinFrame ( BltinFrame ) : <EOL> def run ( self , x ) : <EOL> return self . code . func ( x ) <EOL> bltin_code_for_f = BltinCode ( bltin_code_frame_f , FBltinFrame ) <EOL> bltin_code_for_g = BltinCode ( bltin_code_frame_g , GBltinFrame ) <EOL> def bltin_code_frame_confusion ( ) : <EOL> a = bltin_code_for_f . call ( <NUM_LIT:0> ) <EOL> a1 = bltin_code_for_f . call ( <NUM_LIT:1> ) <EOL> b = bltin_code_for_g . call ( "<STR_LIT:a>" ) <EOL> b1 = bltin_code_for_g . call ( "<STR_LIT:b>" ) <EOL> return ( a , a1 , b , b1 ) <EOL> class BltinCodeReorg : <EOL> def __init__ ( self , framecls ) : <EOL> self . framecls = framecls <EOL> def call ( self , x ) : <EOL> frame = self . framecls ( ) <EOL> frame . set ( x ) <EOL> return frame . run ( ) <EOL> class BltinFrameReorg : <EOL> def __init__ ( self ) : <EOL> pass <EOL> def set ( self , x ) : <EOL> pass <EOL> def run ( self ) : <EOL> pass <EOL> class FBltinFrameReorg ( BltinFrameReorg ) : <EOL> def set ( self , x ) : <EOL> self . arg = int ( x ) <EOL> def run ( self ) : <EOL> return bltin_code_frame_f ( self . arg ) <EOL> class GBltinFrameReorg ( BltinFrameReorg ) : <EOL> def set ( self , x ) : <EOL> self . arg = str ( x ) <EOL> def run ( self ) : <EOL> return bltin_code_frame_g ( self . arg ) <EOL> bltin_code_for_f_reorg = BltinCodeReorg ( FBltinFrameReorg ) <EOL> bltin_code_for_g_reorg = BltinCodeReorg ( GBltinFrameReorg ) <EOL> def bltin_code_frame_reorg ( ) : <EOL> a = bltin_code_for_f_reorg . call ( <NUM_LIT:0> ) <EOL> a1 = bltin_code_for_f_reorg . call ( <NUM_LIT:1> ) <EOL> b = bltin_code_for_g_reorg . call ( "<STR_LIT:a>" ) <EOL> b1 = bltin_code_for_g_reorg . call ( "<STR_LIT:b>" ) <EOL> return ( a , a1 , b , b1 ) <EOL> class Thing1 : <EOL> def __init__ ( self ) : <EOL> self . thingness = <NUM_LIT:1> <EOL> thing1 = Thing1 ( ) <EOL> def one_thing1 ( ) : <EOL> return thing1 <EOL> class Thing2 ( long ) : <EOL> def __new__ ( t , v ) : <EOL> return long . __new__ ( t , v * <NUM_LIT:2> ) <EOL> thing2 = Thing2 ( <NUM_LIT:2> ) <EOL> def one_thing2 ( ) : <EOL> return thing2 <EOL> class Stk : <EOL> def __init__ ( self ) : <EOL> self . itms = [ ] <EOL> def push ( self , v ) : <EOL> self . itms . append ( v ) <EOL> class EC : <EOL> def __init__ ( self ) : <EOL> self . stk = Stk ( ) <EOL> def enter ( self , f ) : <EOL> self . stk . push ( f ) <EOL> def propagation_of_fresh_instances_through_attrs ( x ) : <EOL> e = EC ( ) <EOL> e . enter ( x ) <EOL> class R : <EOL> def __init__ ( self , n ) : <EOL> if n > <NUM_LIT:0> : <EOL> self . r = R ( n - <NUM_LIT:1> ) <EOL> else : <EOL> self . r = None <EOL> self . n = n <EOL> if self . r : <EOL> self . m = self . r . n <EOL> else : <EOL> self . m = - <NUM_LIT:1> <EOL> def make_r ( n ) : <EOL> return R ( n ) <EOL> class B : <EOL> pass <EOL> class Even ( B ) : <EOL> def __init__ ( self , n ) : <EOL> if n > <NUM_LIT:0> : <EOL> self . x = [ Odd ( n - <NUM_LIT:1> ) ] <EOL> self . y = self . x [ <NUM_LIT:0> ] . x <EOL> else : <EOL> self . x = [ ] <EOL> self . y = [ ] <EOL> class Odd ( B ) : <EOL> def __init__ ( self , n ) : <EOL> self . x = [ Even ( n - <NUM_LIT:1> ) ] <EOL> self . y = self . x [ <NUM_LIT:0> ] . x <EOL> def make_eo ( n ) : <EOL> if n % <NUM_LIT:2> == <NUM_LIT:0> : <EOL> return Even ( n ) <EOL> else : <EOL> return Odd ( n ) <EOL> class Box : <EOL> pass <EOL> class Box2 : <EOL> pass <EOL> class Box3 ( Box2 ) : <EOL> pass <EOL> def flow_rev_numbers ( n ) : <EOL> bx3 = Box3 ( ) <EOL> bx3 . x = <NUM_LIT:1> <EOL> bx = Box ( ) <EOL> bx . bx3 = bx3 <EOL> if n > <NUM_LIT:0> : <EOL> z = bx . bx3 . x <EOL> if n > <NUM_LIT:0> : <EOL> bx2 = Box2 ( ) <EOL> bx2 . x = <NUM_LIT:3> <EOL> return z <EOL> raise Exception <EOL> class PolyStk : <EOL> _annspecialcase_ = "<STR_LIT>" <EOL> def __init__ ( self ) : <EOL> self . itms = [ ] <EOL> def push ( self , v ) : <EOL> self . itms . append ( v ) <EOL> def top ( self ) : <EOL> return self . itms [ - <NUM_LIT:1> ] <EOL> def class_spec ( ) : <EOL> istk = PolyStk ( ) <EOL> istk . push ( <NUM_LIT:1> ) <EOL> sstk = PolyStk ( ) <EOL> sstk . push ( "<STR_LIT:a>" ) <EOL> istk . push ( <NUM_LIT:2> ) <EOL> sstk . push ( "<STR_LIT:b>" ) <EOL> return istk . top ( ) , sstk . top ( ) <EOL> from pypy . rlib . rarithmetic import ovfcheck , ovfcheck_lshift <EOL> def add_func ( i = numtype ) : <EOL> try : <EOL> return ovfcheck ( i + <NUM_LIT:1> ) <EOL> except OverflowError : <EOL> raise <EOL> from sys import maxint <EOL> def div_func ( i = numtype ) : <EOL> try : <EOL> return ovfcheck ( ( - maxint - <NUM_LIT:1> ) // i ) <EOL> except ( OverflowError , ZeroDivisionError ) : <EOL> raise <EOL> def mul_func ( x = numtype , y = numtype ) : <EOL> try : <EOL> return ovfcheck ( x * y ) <EOL> except OverflowError : <EOL> raise <EOL> def mod_func ( i = numtype ) : <EOL> try : <EOL> return ovfcheck ( ( - maxint - <NUM_LIT:1> ) % i ) <EOL> except OverflowError : <EOL> raise <EOL> except ZeroDivisionError : <EOL> raise <EOL> def rshift_func ( i = numtype ) : <EOL> try : <EOL> return ( - maxint - <NUM_LIT:1> ) >> i <EOL> except ValueError : <EOL> raise <EOL> class hugelmugel ( OverflowError ) : pass <EOL> def hugo ( a , b , c ) : pass <EOL> def lshift_func ( i = numtype ) : <EOL> try : <EOL> hugo ( <NUM_LIT:2> , <NUM_LIT:3> , <NUM_LIT:5> ) <EOL> return ovfcheck_lshift ( ( - maxint - <NUM_LIT:1> ) , i ) <EOL> except ( hugelmugel , OverflowError , StandardError , ValueError ) : <EOL> raise <EOL> def unary_func ( i = numtype ) : <EOL> try : <EOL> return ovfcheck ( - i ) , ovfcheck ( abs ( i - <NUM_LIT:1> ) ) <EOL> except : raise </s>
