<s> """<STR_LIT>""" <EOL> from __future__ import division <EOL> from warnings import warn as _warn <EOL> from types import MethodType as _MethodType , BuiltinMethodType as _BuiltinMethodType <EOL> from math import log as _log , exp as _exp , pi as _pi , e as _e , ceil as _ceil <EOL> from math import sqrt as _sqrt , acos as _acos , cos as _cos , sin as _sin <EOL> from os import urandom as _urandom <EOL> from binascii import hexlify as _hexlify <EOL> __all__ = [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT>" , <EOL> "<STR_LIT>" ] <EOL> NV_MAGICCONST = <NUM_LIT:4> * _exp ( - <NUM_LIT:0.5> ) / _sqrt ( <NUM_LIT> ) <EOL> TWOPI = <NUM_LIT> * _pi <EOL> LOG4 = _log ( <NUM_LIT> ) <EOL> SG_MAGICCONST = <NUM_LIT:1.0> + _log ( <NUM_LIT> ) <EOL> BPF = <NUM_LIT> <EOL> RECIP_BPF = <NUM_LIT:2> ** - BPF <EOL> import _random <EOL> class Random ( _random . Random ) : <EOL> """<STR_LIT>""" <EOL> VERSION = <NUM_LIT:3> <EOL> def __init__ ( self , x = None ) : <EOL> """<STR_LIT>""" <EOL> self . seed ( x ) <EOL> self . gauss_next = None <EOL> def seed ( self , a = None ) : <EOL> """<STR_LIT>""" <EOL> if a is None : <EOL> try : <EOL> a = long ( _hexlify ( _urandom ( <NUM_LIT:16> ) ) , <NUM_LIT:16> ) <EOL> except NotImplementedError : <EOL> import time <EOL> a = long ( time . time ( ) * <NUM_LIT> ) <EOL> super ( Random , self ) . seed ( a ) <EOL> self . gauss_next = None <EOL> def getstate ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . VERSION , super ( Random , self ) . getstate ( ) , self . gauss_next <EOL> def setstate ( self , state ) : <EOL> """<STR_LIT>""" <EOL> version = state [ <NUM_LIT:0> ] <EOL> if version == <NUM_LIT:3> : <EOL> version , internalstate , self . gauss_next = state <EOL> super ( Random , self ) . setstate ( internalstate ) <EOL> elif version == <NUM_LIT:2> : <EOL> version , internalstate , self . gauss_next = state <EOL> try : <EOL> internalstate = tuple ( long ( x ) % ( <NUM_LIT:2> ** <NUM_LIT:32> ) for x in internalstate ) <EOL> except ValueError , e : <EOL> raise TypeError , e <EOL> super ( Random , self ) . setstate ( internalstate ) <EOL> else : <EOL> raise ValueError ( "<STR_LIT>" <EOL> "<STR_LIT>" % <EOL> ( version , self . VERSION ) ) <EOL> def __getstate__ ( self ) : <EOL> return self . getstate ( ) <EOL> def __setstate__ ( self , state ) : <EOL> self . setstate ( state ) <EOL> def __reduce__ ( self ) : <EOL> return self . __class__ , ( ) , self . getstate ( ) <EOL> def randrange ( self , start , stop = None , step = <NUM_LIT:1> , int = int , default = None , <EOL> maxwidth = <NUM_LIT:1> L << BPF ) : <EOL> """<STR_LIT>""" <EOL> istart = int ( start ) <EOL> if istart != start : <EOL> raise ValueError , "<STR_LIT>" <EOL> if stop is default : <EOL> if istart > <NUM_LIT:0> : <EOL> if istart >= maxwidth : <EOL> return self . _randbelow ( istart ) <EOL> return int ( self . random ( ) * istart ) <EOL> raise ValueError , "<STR_LIT>" <EOL> istop = int ( stop ) <EOL> if istop != stop : <EOL> raise ValueError , "<STR_LIT>" <EOL> width = istop - istart <EOL> if step == <NUM_LIT:1> and width > <NUM_LIT:0> : <EOL> if width >= maxwidth : <EOL> return int ( istart + self . _randbelow ( width ) ) <EOL> return int ( istart + int ( self . random ( ) * width ) ) <EOL> if step == <NUM_LIT:1> : <EOL> raise ValueError , "<STR_LIT>" % ( istart , istop , width ) <EOL> istep = int ( step ) <EOL> if istep != step : <EOL> raise ValueError , "<STR_LIT>" <EOL> if istep > <NUM_LIT:0> : <EOL> n = ( width + istep - <NUM_LIT:1> ) // istep <EOL> elif istep < <NUM_LIT:0> : <EOL> n = ( width + istep + <NUM_LIT:1> ) // istep <EOL> else : <EOL> raise ValueError , "<STR_LIT>" <EOL> if n <= <NUM_LIT:0> : <EOL> raise ValueError , "<STR_LIT>" <EOL> if n >= maxwidth : <EOL> return istart + istep * self . _randbelow ( n ) <EOL> return istart + istep * int ( self . random ( ) * n ) <EOL> def randint ( self , a , b ) : <EOL> """<STR_LIT>""" <EOL> return self . randrange ( a , b + <NUM_LIT:1> ) <EOL> def _randbelow ( self , n , _log = _log , int = int , _maxwidth = <NUM_LIT:1> L << BPF , <EOL> _Method = _MethodType , _BuiltinMethod = _BuiltinMethodType ) : <EOL> """<STR_LIT>""" <EOL> try : <EOL> getrandbits = self . getrandbits <EOL> except AttributeError : <EOL> pass <EOL> else : <EOL> if type ( self . random ) is _BuiltinMethod or type ( getrandbits ) is _Method : <EOL> k = int ( <NUM_LIT> + _log ( n - <NUM_LIT:1> , <NUM_LIT> ) ) <EOL> r = getrandbits ( k ) <EOL> while r >= n : <EOL> r = getrandbits ( k ) <EOL> return r <EOL> if n >= _maxwidth : <EOL> _warn ( "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> return int ( self . random ( ) * n ) <EOL> def choice ( self , seq ) : <EOL> """<STR_LIT>""" <EOL> return seq [ int ( self . random ( ) * len ( seq ) ) ] <EOL> def shuffle ( self , x , random = None , int = int ) : <EOL> """<STR_LIT>""" <EOL> if random is None : <EOL> random = self . random <EOL> for i in reversed ( xrange ( <NUM_LIT:1> , len ( x ) ) ) : <EOL> j = int ( random ( ) * ( i + <NUM_LIT:1> ) ) <EOL> x [ i ] , x [ j ] = x [ j ] , x [ i ] <EOL> def sample ( self , population , k ) : <EOL> """<STR_LIT>""" <EOL> n = len ( population ) <EOL> if not <NUM_LIT:0> <= k <= n : <EOL> raise ValueError , "<STR_LIT>" <EOL> random = self . random <EOL> _int = int <EOL> result = [ None ] * k <EOL> setsize = <NUM_LIT> <EOL> if k > <NUM_LIT:5> : <EOL> setsize += <NUM_LIT:4> ** _ceil ( _log ( k * <NUM_LIT:3> , <NUM_LIT:4> ) ) <EOL> if n <= setsize or hasattr ( population , "<STR_LIT>" ) : <EOL> pool = list ( population ) <EOL> for i in xrange ( k ) : <EOL> j = _int ( random ( ) * ( n - i ) ) <EOL> result [ i ] = pool [ j ] <EOL> pool [ j ] = pool [ n - i - <NUM_LIT:1> ] <EOL> else : <EOL> try : <EOL> selected = set ( ) <EOL> selected_add = selected . add <EOL> for i in xrange ( k ) : <EOL> j = _int ( random ( ) * n ) <EOL> while j in selected : <EOL> j = _int ( random ( ) * n ) <EOL> selected_add ( j ) <EOL> result [ i ] = population [ j ] <EOL> except ( TypeError , KeyError ) : <EOL> if isinstance ( population , list ) : <EOL> raise <EOL> return self . sample ( tuple ( population ) , k ) <EOL> return result <EOL> def uniform ( self , a , b ) : <EOL> """<STR_LIT>""" <EOL> return a + ( b - a ) * self . random ( ) <EOL> def triangular ( self , low = <NUM_LIT:0.0> , high = <NUM_LIT:1.0> , mode = None ) : <EOL> """<STR_LIT>""" <EOL> u = self . random ( ) <EOL> c = <NUM_LIT:0.5> if mode is None else ( mode - low ) / ( high - low ) <EOL> if u > c : <EOL> u = <NUM_LIT:1.0> - u <EOL> c = <NUM_LIT:1.0> - c <EOL> low , high = high , low <EOL> return low + ( high - low ) * ( u * c ) ** <NUM_LIT:0.5> <EOL> def normalvariate ( self , mu , sigma ) : <EOL> """<STR_LIT>""" <EOL> random = self . random <EOL> while <NUM_LIT:1> : <EOL> u1 = random ( ) <EOL> u2 = <NUM_LIT:1.0> - random ( ) <EOL> z = NV_MAGICCONST * ( u1 - <NUM_LIT:0.5> ) / u2 <EOL> zz = z * z / <NUM_LIT> <EOL> if zz <= - _log ( u2 ) : <EOL> break <EOL> return mu + z * sigma <EOL> def lognormvariate ( self , mu , sigma ) : <EOL> """<STR_LIT>""" <EOL> return _exp ( self . normalvariate ( mu , sigma ) ) <EOL> def expovariate ( self , lambd ) : <EOL> """<STR_LIT>""" <EOL> random = self . random <EOL> u = random ( ) <EOL> while u <= <NUM_LIT> : <EOL> u = random ( ) <EOL> return - _log ( u ) / lambd <EOL> def vonmisesvariate ( self , mu , kappa ) : <EOL> """<STR_LIT>""" <EOL> random = self . random <EOL> if kappa <= <NUM_LIT> : <EOL> return TWOPI * random ( ) <EOL> a = <NUM_LIT:1.0> + _sqrt ( <NUM_LIT:1.0> + <NUM_LIT> * kappa * kappa ) <EOL> b = ( a - _sqrt ( <NUM_LIT> * a ) ) / ( <NUM_LIT> * kappa ) <EOL> r = ( <NUM_LIT:1.0> + b * b ) / ( <NUM_LIT> * b ) <EOL> while <NUM_LIT:1> : <EOL> u1 = random ( ) <EOL> z = _cos ( _pi * u1 ) <EOL> f = ( <NUM_LIT:1.0> + r * z ) / ( r + z ) <EOL> c = kappa * ( r - f ) <EOL> u2 = random ( ) <EOL> if u2 < c * ( <NUM_LIT> - c ) or u2 <= c * _exp ( <NUM_LIT:1.0> - c ) : <EOL> break <EOL> u3 = random ( ) <EOL> if u3 > <NUM_LIT:0.5> : <EOL> theta = ( mu % TWOPI ) + _acos ( f ) <EOL> else : <EOL> theta = ( mu % TWOPI ) - _acos ( f ) <EOL> return theta <EOL> def gammavariate ( self , alpha , beta ) : <EOL> """<STR_LIT>""" <EOL> if alpha <= <NUM_LIT:0.0> or beta <= <NUM_LIT:0.0> : <EOL> raise ValueError , '<STR_LIT>' <EOL> random = self . random <EOL> if alpha > <NUM_LIT:1.0> : <EOL> ainv = _sqrt ( <NUM_LIT> * alpha - <NUM_LIT:1.0> ) <EOL> bbb = alpha - LOG4 <EOL> ccc = alpha + ainv <EOL> while <NUM_LIT:1> : <EOL> u1 = random ( ) <EOL> if not <NUM_LIT> < u1 < <NUM_LIT> : <EOL> continue <EOL> u2 = <NUM_LIT:1.0> - random ( ) <EOL> v = _log ( u1 / ( <NUM_LIT:1.0> - u1 ) ) / ainv <EOL> x = alpha * _exp ( v ) <EOL> z = u1 * u1 * u2 <EOL> r = bbb + ccc * v - x <EOL> if r + SG_MAGICCONST - <NUM_LIT> * z >= <NUM_LIT:0.0> or r >= _log ( z ) : <EOL> return x * beta <EOL> elif alpha == <NUM_LIT:1.0> : <EOL> u = random ( ) <EOL> while u <= <NUM_LIT> : <EOL> u = random ( ) <EOL> return - _log ( u ) * beta <EOL> else : <EOL> while <NUM_LIT:1> : <EOL> u = random ( ) <EOL> b = ( _e + alpha ) / _e <EOL> p = b * u <EOL> if p <= <NUM_LIT:1.0> : <EOL> x = p ** ( <NUM_LIT:1.0> / alpha ) <EOL> else : <EOL> x = - _log ( ( b - p ) / alpha ) <EOL> u1 = random ( ) <EOL> if p > <NUM_LIT:1.0> : <EOL> if u1 <= x ** ( alpha - <NUM_LIT:1.0> ) : <EOL> break <EOL> elif u1 <= _exp ( - x ) : <EOL> break <EOL> return x * beta <EOL> def gauss ( self , mu , sigma ) : <EOL> """<STR_LIT>""" <EOL> random = self . random <EOL> z = self . gauss_next <EOL> self . gauss_next = None <EOL> if z is None : <EOL> x2pi = random ( ) * TWOPI <EOL> g2rad = _sqrt ( - <NUM_LIT> * _log ( <NUM_LIT:1.0> - random ( ) ) ) <EOL> z = _cos ( x2pi ) * g2rad <EOL> self . gauss_next = _sin ( x2pi ) * g2rad <EOL> return mu + z * sigma <EOL> def betavariate ( self , alpha , beta ) : <EOL> """<STR_LIT>""" <EOL> y = self . gammavariate ( alpha , <NUM_LIT:1.> ) <EOL> if y == <NUM_LIT:0> : <EOL> return <NUM_LIT:0.0> <EOL> else : <EOL> return y / ( y + self . gammavariate ( beta , <NUM_LIT:1.> ) ) <EOL> def paretovariate ( self , alpha ) : <EOL> """<STR_LIT>""" <EOL> u = <NUM_LIT:1.0> - self . random ( ) <EOL> return <NUM_LIT:1.0> / pow ( u , <NUM_LIT:1.0> / alpha ) <EOL> def weibullvariate ( self , alpha , beta ) : <EOL> """<STR_LIT>""" <EOL> u = <NUM_LIT:1.0> - self . random ( ) <EOL> return alpha * pow ( - _log ( u ) , <NUM_LIT:1.0> / beta ) <EOL> class WichmannHill ( Random ) : <EOL> VERSION = <NUM_LIT:1> <EOL> def seed ( self , a = None ) : <EOL> """<STR_LIT>""" <EOL> if a is None : <EOL> try : <EOL> a = long ( _hexlify ( _urandom ( <NUM_LIT:16> ) ) , <NUM_LIT:16> ) <EOL> except NotImplementedError : <EOL> import time <EOL> a = long ( time . time ( ) * <NUM_LIT> ) <EOL> if not isinstance ( a , ( int , long ) ) : <EOL> a = hash ( a ) <EOL> a , x = divmod ( a , <NUM_LIT> ) <EOL> a , y = divmod ( a , <NUM_LIT> ) <EOL> a , z = divmod ( a , <NUM_LIT> ) <EOL> self . _seed = int ( x ) + <NUM_LIT:1> , int ( y ) + <NUM_LIT:1> , int ( z ) + <NUM_LIT:1> <EOL> self . gauss_next = None <EOL> def random ( self ) : <EOL> """<STR_LIT>""" <EOL> x , y , z = self . _seed <EOL> x = ( <NUM_LIT> * x ) % <NUM_LIT> <EOL> y = ( <NUM_LIT> * y ) % <NUM_LIT> <EOL> z = ( <NUM_LIT> * z ) % <NUM_LIT> <EOL> self . _seed = x , y , z <EOL> return ( x / <NUM_LIT> + y / <NUM_LIT> + z / <NUM_LIT> ) % <NUM_LIT:1.0> <EOL> def getstate ( self ) : <EOL> """<STR_LIT>""" <EOL> return self . VERSION , self . _seed , self . gauss_next <EOL> def setstate ( self , state ) : <EOL> """<STR_LIT>""" <EOL> version = state [ <NUM_LIT:0> ] <EOL> if version == <NUM_LIT:1> : <EOL> version , self . _seed , self . gauss_next = state <EOL> else : <EOL> raise ValueError ( "<STR_LIT>" <EOL> "<STR_LIT>" % <EOL> ( version , self . VERSION ) ) <EOL> def jumpahead ( self , n ) : <EOL> """<STR_LIT>""" <EOL> if not n >= <NUM_LIT:0> : <EOL> raise ValueError ( "<STR_LIT>" ) <EOL> x , y , z = self . _seed <EOL> x = int ( x * pow ( <NUM_LIT> , n , <NUM_LIT> ) ) % <NUM_LIT> <EOL> y = int ( y * pow ( <NUM_LIT> , n , <NUM_LIT> ) ) % <NUM_LIT> <EOL> z = int ( z * pow ( <NUM_LIT> , n , <NUM_LIT> ) ) % <NUM_LIT> <EOL> self . _seed = x , y , z <EOL> def __whseed ( self , x = <NUM_LIT:0> , y = <NUM_LIT:0> , z = <NUM_LIT:0> ) : <EOL> """<STR_LIT>""" <EOL> if not type ( x ) == type ( y ) == type ( z ) == int : <EOL> raise TypeError ( '<STR_LIT>' ) <EOL> if not ( <NUM_LIT:0> <= x < <NUM_LIT> and <NUM_LIT:0> <= y < <NUM_LIT> and <NUM_LIT:0> <= z < <NUM_LIT> ) : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> if <NUM_LIT:0> == x == y == z : <EOL> import time <EOL> t = long ( time . time ( ) * <NUM_LIT> ) <EOL> t = int ( ( t & <NUM_LIT> ) ^ ( t >> <NUM_LIT> ) ) <EOL> t , x = divmod ( t , <NUM_LIT> ) <EOL> t , y = divmod ( t , <NUM_LIT> ) <EOL> t , z = divmod ( t , <NUM_LIT> ) <EOL> self . _seed = ( x or <NUM_LIT:1> , y or <NUM_LIT:1> , z or <NUM_LIT:1> ) <EOL> self . gauss_next = None <EOL> def whseed ( self , a = None ) : <EOL> """<STR_LIT>""" <EOL> if a is None : <EOL> self . __whseed ( ) <EOL> return <EOL> a = hash ( a ) <EOL> a , x = divmod ( a , <NUM_LIT> ) <EOL> a , y = divmod ( a , <NUM_LIT> ) <EOL> a , z = divmod ( a , <NUM_LIT> ) <EOL> x = ( x + a ) % <NUM_LIT> or <NUM_LIT:1> <EOL> y = ( y + a ) % <NUM_LIT> or <NUM_LIT:1> <EOL> z = ( z + a ) % <NUM_LIT> or <NUM_LIT:1> <EOL> self . __whseed ( x , y , z ) <EOL> class SystemRandom ( Random ) : <EOL> """<STR_LIT>""" <EOL> def random ( self ) : <EOL> """<STR_LIT>""" <EOL> return ( long ( _hexlify ( _urandom ( <NUM_LIT:7> ) ) , <NUM_LIT:16> ) >> <NUM_LIT:3> ) * RECIP_BPF <EOL> def getrandbits ( self , k ) : <EOL> """<STR_LIT>""" <EOL> if k <= <NUM_LIT:0> : <EOL> raise ValueError ( '<STR_LIT>' ) <EOL> if k != int ( k ) : <EOL> raise TypeError ( '<STR_LIT>' ) <EOL> bytes = ( k + <NUM_LIT:7> ) // <NUM_LIT:8> <EOL> x = long ( _hexlify ( _urandom ( bytes ) ) , <NUM_LIT:16> ) <EOL> return x >> ( bytes * <NUM_LIT:8> - k ) <EOL> def _stub ( self , * args , ** kwds ) : <EOL> "<STR_LIT>" <EOL> return None <EOL> seed = jumpahead = _stub <EOL> def _notimplemented ( self , * args , ** kwds ) : <EOL> "<STR_LIT>" <EOL> raise NotImplementedError ( '<STR_LIT>' ) <EOL> getstate = setstate = _notimplemented <EOL> def _test_generator ( n , func , args ) : <EOL> import time <EOL> print n , '<STR_LIT>' , func . __name__ <EOL> total = <NUM_LIT:0.0> <EOL> sqsum = <NUM_LIT:0.0> <EOL> smallest = <NUM_LIT> <EOL> largest = - <NUM_LIT> <EOL> t0 = time . time ( ) <EOL> for i in range ( n ) : <EOL> x = func ( * args ) <EOL> total += x <EOL> sqsum = sqsum + x * x <EOL> smallest = min ( x , smallest ) <EOL> largest = max ( x , largest ) <EOL> t1 = time . time ( ) <EOL> print round ( t1 - t0 , <NUM_LIT:3> ) , '<STR_LIT>' , <EOL> avg = total / n <EOL> stddev = _sqrt ( sqsum / n - avg * avg ) <EOL> print '<STR_LIT>' % ( avg , stddev , smallest , largest ) <EOL> def _test ( N = <NUM_LIT> ) : <EOL> _test_generator ( N , random , ( ) ) <EOL> _test_generator ( N , normalvariate , ( <NUM_LIT:0.0> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , lognormvariate , ( <NUM_LIT:0.0> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , vonmisesvariate , ( <NUM_LIT:0.0> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT:0.1> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT:0.1> , <NUM_LIT> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT:0.5> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT:1.0> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gammavariate , ( <NUM_LIT> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , gauss , ( <NUM_LIT:0.0> , <NUM_LIT:1.0> ) ) <EOL> _test_generator ( N , betavariate , ( <NUM_LIT> , <NUM_LIT> ) ) <EOL> _test_generator ( N , triangular , ( <NUM_LIT:0.0> , <NUM_LIT:1.0> , <NUM_LIT:1.0> / <NUM_LIT> ) ) <EOL> _inst = Random ( ) <EOL> seed = _inst . seed <EOL> random = _inst . random <EOL> uniform = _inst . uniform <EOL> triangular = _inst . triangular <EOL> randint = _inst . randint <EOL> choice = _inst . choice <EOL> randrange = _inst . randrange <EOL> sample = _inst . sample <EOL> shuffle = _inst . shuffle <EOL> normalvariate = _inst . normalvariate <EOL> lognormvariate = _inst . lognormvariate <EOL> expovariate = _inst . expovariate <EOL> vonmisesvariate = _inst . vonmisesvariate <EOL> gammavariate = _inst . gammavariate <EOL> gauss = _inst . gauss <EOL> betavariate = _inst . betavariate <EOL> paretovariate = _inst . paretovariate <EOL> weibullvariate = _inst . weibullvariate <EOL> getstate = _inst . getstate <EOL> setstate = _inst . setstate <EOL> jumpahead = _inst . jumpahead <EOL> getrandbits = _inst . getrandbits <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> _test ( ) </s>
