[c|tXddlmZmZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z eedoejdd kZd ZeedZd Zd Zd ZdZd2dZGddeZGddeZdZed3dZGddeZdZdZdZ dZ!GddeZ"dZ#edZ$d Z%Gd!d"eZ&d#Z'ere'Z(d$Z'd%e'_)d4d&Z*d4d'Z+d4d(Z,d4d)Z-d4d*Z.d4d+Z/d,e*_)d-e+_)d.e,_)d/e-_)d0e._)dd1l0m1Z2dS)5)reducepartialN) attrgetternot_) import_module MethodType) no_defaultpypy_version_info)identityapply thread_first thread_lastmemoizecompose compose_leftpipe complementjuxtdocurryflipexceptsc|S)z< Identity function. Return x >>> identity(3) 3 )xs /lib/python3.11/site-packages/toolz/functoolz.pyrrs HcX|std|d|dd}}||i|S)z Applies a function and returns the results >>> def double(x): return 2*x >>> def inc(x): return x + 1 >>> apply(double, 5) 10 >>> tuple(map(apply, [double, inc, double], [10, 500, 8000])) (20, 501, 16000) zfunc argument is requiredrr N) TypeError) func_and_argskwargsfuncargss rrrsG 53444q!=#4$D 4   r c*d}t|||S)a@ Thread value through a sequence of functions/forms >>> def double(x): return 2*x >>> def inc(x): return x + 1 >>> thread_first(1, inc, double) 4 If the function expects more than one input you can specify those inputs in a tuple. The value is used as the first input. >>> def add(x, y): return x + y >>> def pow(x, y): return x**y >>> thread_first(1, (add, 4), (pow, 2)) # pow(add(1, 4), 2) 25 So in general thread_first(x, f, (g, y, z)) expands to g(f(x), y, z) See Also: thread_last ct|r ||St|tr|d|dd}}|f|z}||SdSNrr callable isinstancetuplevalformr%r&s revalform_frontz$thread_first..evalform_frontFsf D>> 499  dE " " a$qrr($D6D=D4;   r r)r/formsr1s rrr.s%0 .% - --r c*d}t|||S)a Thread value through a sequence of functions/forms >>> def double(x): return 2*x >>> def inc(x): return x + 1 >>> thread_last(1, inc, double) 4 If the function expects more than one input you can specify those inputs in a tuple. The value is used as the last input. >>> def add(x, y): return x + y >>> def pow(x, y): return x**y >>> thread_last(1, (add, 4), (pow, 2)) # pow(2, add(4, 1)) 32 So in general thread_last(x, f, (g, y, z)) expands to g(y, z, f(x)) >>> def iseven(x): ... return x % 2 == 0 >>> list(thread_last([1, 2, 3], (map, inc), (filter, iseven))) [2, 4] See Also: thread_first ct|r ||St|tr|d|dd}}||fz}||SdSr)r*r.s r evalform_backz"thread_last..evalform_backmsf D>> 499  dE " " a$qrr($D3&=D4;   r r2)r/r3r6s rrrPs%: - , ,,r c`|tt||||St|||||S)a Like @property, but returns ``classval`` when used as a class attribute >>> class MyClass(object): ... '''The class docstring''' ... @instanceproperty(classval=__doc__) ... def __doc__(self): ... return 'An object docstring' ... @instanceproperty ... def val(self): ... return 42 ... >>> MyClass.__doc__ 'The class docstring' >>> MyClass.val is None True >>> obj = MyClass() >>> obj.__doc__ 'An object docstring' >>> obj.val 42 N)fsetfdeldocclassvalfgetr8r9r:r;)rinstancepropertyInstancePropertyr<s rr>r>wsQ, *'d3 (*** * Dt%- / / //r c,eZdZdZ ddZddZdZdS)r?z Like @property, but returns ``classval`` when used as a class attribute Should not be used directly. Use ``instanceproperty`` instead. NcR||_t|||||dS)N)r=r8r9r:)r;property__init__)selfr=r8r9r:r;s rrCzInstanceProperty.__init__s.  $T4SIIIIIr cL||jSt|||SN)r;rB__get__)rDobjtypes rrGzInstanceProperty.__get__s*  != c4000r cT|j|j|j|j|jf}t |fSrF)r=r8r9__doc__r;r?rDstates r __reduce__zInstanceProperty.__reduce__s'DIty$, N&&r NNNNNrF)__name__ __module__ __qualname__rKrCrGrNrr rr?r?sb=AJJJJ 1111 '''''r r?ceZdZdZdZedZedZedZedZ edZ dZ d Z d Z d Zd Zd ZddZdZdZdZdZdS)rak Curry a callable function Enables partial application of arguments through calling a function with an incomplete set of arguments. >>> def mul(x, y): ... return x * y >>> mul = curry(mul) >>> double = mul(2) >>> double(10) 20 Also supports keyword arguments >>> @curry # Can use curry as a decorator ... def f(x, y, a=10): ... return a * (x + y) >>> add = f(a=1) >>> add(2, 3) 5 See Also: toolz.curried - namespace of curried functions https://toolz.readthedocs.io/en/latest/curry.html c|std|d|dd}}t|stdt|drt|drut|dret|jt rKi}|jr||j|||}|j|z}|j}|rt|g|Ri||_ nt|g|R|_ t|dd|_ t|d d |_ t|d d|_t|d d|_d|_d|_dS) Nz/__init__() takes at least 2 arguments (1 given)rr zInput must be callabler%r&keywordsrKrPzrQrR)r"r+hasattrr,r&r-rUupdater%r_partialgetattrrKrPrQrR_sigspec_has_unknown_args)rDr&r$r%_kwargss rrCzcurry.__init__s OMNN N!Wd122hd~~ 6455 5 D& ! ! f%% j)) 49e,,  G} .t}--- NN6 " " "F9t#D9D  1#D:4:::6::DMM#D04000DMtY55 j)<< !$ d;;#D.$?? !%r c|jjSrF)rXr%rDs rr%z curry.func }!!r ctj|j}|jpd}|jpi}t |j|||durt dt|j }d}|dt|D]}|j |j krn|dz }d}g}||dD]}|j } |j } | |jkrnH| |j kr|r*n9|j|vr||j} |j} d}n|r|j} | |jurt$} ||| | ||S) NrFz$curry object has incorrect argumentsrr T)defaultkind) parameters)inspect signaturer%r&rUis_partial_argsr"listrcvalueslenrbVAR_POSITIONALra VAR_KEYWORDname KEYWORD_ONLYemptyr appendreplace) rDsigr&rUparamsskipparamkwonly newparamsrbras r __signature__zcurry.__signature__s **yB=&B 49dHc : :e C DBCC Ccn++--..JSYYJ'  EzU11  AIDD DEE] H HE:DmGu(( )-- )x' )"5:.). -Dek))(G   U]]7]FF G G G G{{i{000r c|jjSrF)rXr&r^s rr&z curry.argsr_r c|jjSrF)rXrUr^s rrUzcurry.keywordss }%%r c|jSrFrPr^s r func_namezcurry.func_names }r c*t|jSrF)strr%r^s r__str__z curry.__str__s49~~r c*t|jSrF)reprr%r^s r__repr__zcurry.__repr__sDIr ct|j|j|jr&t |jndfSrF)hashr%r&rU frozensetitemsr^s r__hash__zcurry.__hash__"sITY 9=Yt}2244555 !! !r ct|to/|j|jko|j|jko|j|jkSrF)r,rr%r&rUrDothers r__eq__z curry.__eq__'sJ5%((LTY%*-DL UZ'L,0MU^,K Mr c.|| SrF)rrs r__ne__z curry.__ne__+s;;u%%%%r c |j|i|S#t$r/}||||r|j|i|cYd}~Sd}~wwxYwrF)rXr" _should_currybind)rDr&r$excs r__call__zcurry.__call__.s  4=$1&11 1   !!$44 2 ty$1&11111111  s  A#AAAANcB|j}|j|z}|jrt|jfi|}|j3t j|x}|_t||du|_n|j}t||||durdS|jrdSt||||sdSdSNFT) r%r&rUdictrZ_sigssignature_or_spec has_varargsr[rf is_valid_args)rDr&r$rr%sigspecs rrzcurry._should_curry6syy4 = 3$-22622F = $&+&=d&C&C CGdm%0w%?%?u%LD " "mG 4vw 7 75 @ 5  # 4tT67;; 45r c4t||g|Ri|SrF)rIrDr&r$s rrz curry.bindPs(tDzz$0000000r c|j|i|SrF)rXrs rcallz curry.callSst}d-f---r c*||St||SrF)r)rDinstanceowners rrGz curry.__get__Vs  KT8$$$r c|j}t|dd}t|dd}|t|dd}d}|r|rg}t|}|dD]]}t |t r|d|j}t||d}|n||^t |t r)|j|ur ||u}d|}|d|}td|j D}t|||j |j ||f} t| fS)NrQrRrP.r%:c3,K|]\}}|dv ||fVdS))rXrZNr).0kvs r z#curry.__reduce__..ssH??DAq%==?!Q??????r )r%rYrsplitr,rrojoinr-__dict__rrIr&rU_restore_curry) rDr%modnamequalname is_decoratedattrsrHattruserdictrMs rrNzcurry.__reduce__[sy$ d33466  7tZ66H  5x 5E((C s++ # #c5))#LL((((Cc4..E T""""#u%% 5#(d*: 5"d{ 88E??")''884??DM,?,?,A,A?????dT49dmXu$$r rF)rPrQrRrKrCr>r%rwr&rUr|rrrrrrrrrrGrNrr rrrsh6 & & &D"""#1#1#1J"""&&&!!! MMM&&&4111...%%% %%%%%r rc6t|tr[|dd\}}t|}|dD]} t || }|r|S|j}||g|Ri|pi}|j||S)Nrr r) r,r~rsplitrrrYr%rrW) clsr%r&r$rrrrrHrs rrrzs$ KKQ//G$$NN3'' % %D#t$$CC  Jx #d ,T , , ,fl , ,CL!!! Jr ci tdu}td}n#t$rd}d}YnwxYw|rdn |rdndfd} j|_n#t$rYnwxYwj|_|_|S) aP Cache a function's result for speedy future evaluation Considerations: Trades memory for speed. Only use on pure functions. >>> def add(x, y): return x + y >>> add = memoize(add) Or use as a decorator >>> @memoize ... def add(x, y): ... return x + y Use the ``cache`` keyword to provide a dict-like object as an initial cache >>> @memoize(cache={(1, 2): 3}) ... def add(x, y): ... return x + y Note that the above works as a decorator because ``memoize`` is curried. It is also possible to provide a ``key(args, kwargs)`` function that calculates keys used for the cache, which receives an ``args`` tuple and ``kwargs`` dict as input, and must return a hashable value. However, the default key function should be sufficient most of the time. >>> # Use key function that ignores extraneous keyword arguments >>> @memoize(key=lambda args, kwargs: args) ... def add(x, y, verbose=False): ... if verbose: ... print('Calculating %s + %s' % (x, y)) ... return x + y NFr Tc|dS)Nrrr&r$s rkeyzmemoize..keys Awr cT|pd|r!t|ndfSrF)rrrs rrzmemoize..keys0LD17AIfllnn---Tr c|SrFrrs rrzmemoize..keys r c||} |S#t$rtdt$r|i|x|<}|cYSwxYw)Nz/Arguments to memoized function must be hashable)r"KeyError)r&r$rresultcacher%rs rmemofzmemoize..memofs Cf   8O O O OMNN N    $d 5f 5 5 5E!HvMMM s1A  A ) has_keywordsis_arityr"rPAttributeErrorrK __wrapped__)r%rrmay_have_kwargsis_unaryrs``` rrrs J &t,,E9At$$                         LEME Ls!+<< A%% A21A2ceZdZdZdZdZdZdZdZe edZe d Zd Z d Z d Z d ZddZe dZe edZdS)Composez? A composition of functions See Also: compose firstfuncscvtt|}|d|_|dd|_dSr))r-reversedrrrDrs rrCzCompose.__init__s3huoo&&1X 122Y r cJ|j|i|}|jD] }||}|SrFr)rDr&r$retfs rrzCompose.__call__s=dj$)&))  A!C&&CC r c|j|jfSrFrr^s r __getstate__zCompose.__getstate__sz4:%%r c$|\|_|_dSrFrrLs r __setstate__zCompose.__setstate__s!& DJJJr r;cxfd dt|jf|jzzS#t$rYdSwxYw)Ncf|sdSd|dj|ddS)z.composed_docsA )(($$r!u~r!""v9N$OO Or zlambda *args, **kwargs: zA composition of functions)rrrr)rDrs @rrKzCompose.__doc__sw P P P P P 0* h }tz'ABBCD  0 0 0/// 0s "+ 99c ddt|jf|jzDS#t$rt |jcYSwxYw)N_of_c3$K|] }|jV dSrFr{)rrs rrz#Compose.__name__.. s$JJJJJJJJr )rrrrrrIrPr^s rrPzCompose.__name__ss ';;JJXtzmdj.H%I%IJJJ  ' ' '::& & & & 's9<AAc ~d|tt|jf|jzS)Nz{.__class__.__name__}{!r})rr-rrrr^s rrzCompose.__repr__s=*11 %$*$*!<==>>@@ @r czt|tr |j|jko|j|jkStSrF)r,rrrNotImplementedrs rrzCompose.__eq__s8 eW % % K;$*,J 1J Jr cR||}|turtn| SrF)rr)rDrequalitys rrzCompose.__ne__s);;u%%!)^!;M~~XMr cTt|jt|jz SrF)rrrr^s rrzCompose.__hash__s!DJ$tz"2"222r Nc*||nt||SrFr)rDrHobjtypes rrGzCompose.__get__#s=tt 4(=(==r ctj|j}tj|jd}||jS)N)return_annotation)rdrerrrpr)rDbaselasts rrwzCompose.__signature__'sA ,, B00||d.D|EEEr rrF)rPrQrRrK __slots__rCrrrr>rBrrrrrGrwrrrr rrrs1 !I  &&&'''w'''00('0&''X'@@@ NNN333>>>>FFF #"::g#6#677KKKr rch|stSt|dkr|dSt|S)a Compose functions to operate in series. Returns a function that applies other functions in sequence. Functions are applied from right to left so that ``compose(f, g, h)(x, y)`` is the same as ``f(g(h(x, y)))``. If no arguments are provided, the identity function (f(x) = x) is returned. >>> inc = lambda i: i + 1 >>> compose(str, inc)(3) '4' See Also: compose_left pipe r r)rrirrs rrr0s8$  5zzQQxu~~r c.tt|S)a Compose functions to operate in series. Returns a function that applies other functions in sequence. Functions are applied from left to right so that ``compose_left(f, g, h)(x, y)`` is the same as ``h(g(f(x, y)))``. If no arguments are provided, the identity function (f(x) = x) is returned. >>> inc = lambda i: i + 1 >>> compose_left(inc, str)(3) '4' See Also: compose pipe )rrrs rrrJs$ HUOO $$r c&|D] }||}|S)a Pipe a value through a sequence of functions I.e. ``pipe(data, f, g, h)`` is equivalent to ``h(g(f(data)))`` We think of the value as progressing through a pipe of several transformations, much like pipes in UNIX ``$ cat data | f | g | h`` >>> double = lambda i: 2 * i >>> pipe(3, double, str) '6' See Also: compose compose_left thread_first thread_last r)datarr%s rrr_s'(tDzz Kr c,tt|S)a4 Convert a predicate function to its logical complement. In other words, return a function that, for inputs that normally yield True, yields False, and vice-versa. >>> def iseven(n): return n % 2 == 0 >>> isodd = complement(iseven) >>> iseven(2) True >>> isodd(2) False )rr)r%s rrrxs 4  r c0eZdZdZdgZdZdZdZdZdS)ra Creates a function that calls several functions with the same arguments Takes several functions and returns a function that applies its arguments to each of those functions then returns a tuple of the results. Name comes from juxtaposition: the fact of two things being seen or placed close together with contrasting effect. >>> inc = lambda x: x + 1 >>> double = lambda x: x * 2 >>> juxt(inc, double)(10) (11, 20) >>> juxt([inc, double])(10) (11, 20) rct|dkrt|ds|d}t||_dS)Nr r)rir+r-rrs rrCz juxt.__init__sA u::? 8E!H#5#5 !HE5\\ r cHtfd|jDS)Nc3(K|] }|iV dSrFr)rr%r&r$s rrz juxt.__call__..s2BBtTT4*6**BBBBBBr )r-rrs ``rrz juxt.__call__s,BBBBBtzBBBBBBr c|jSrFrr^s rrzjuxt.__getstate__s zr c||_dSrFrrLs rrzjuxt.__setstate__s  r N) rPrQrRrKrrCrrrrr rrrsf I""" CCCr rc|||S)a Runs ``func`` on ``x``, returns ``x`` Because the results of ``func`` are not returned, only the side effects of ``func`` are relevant. Logging functions can be made by composing ``do`` with a storage function like ``list.append`` or ``file.write`` >>> from toolz import compose >>> from toolz.curried import do >>> log = [] >>> inc = lambda x: x + 1 >>> inc = compose(inc, do(log.append)) >>> inc(1) 2 >>> inc(11) 12 >>> log [1, 11] r)r%rs rrrs, DGGG Hr c|||S)a/ Call the function call with the arguments flipped This function is curried. >>> def div(a, b): ... return a // b ... >>> flip(div, 2, 6) 3 >>> div_by_two = flip(div, 2) >>> div_by_two(4) 2 This is particularly useful for built in functions and functions defined in C extensions that accept positional only arguments. For example: isinstance, issubclass. >>> data = [1, 'a', 'b', 2, 1.5, object(), 3] >>> only_ints = list(filter(flip(isinstance, int), data)) >>> only_ints [1, 2, 3] r)r%abs rrrs0 41::r cdS)z Returns None. Nr)rs r return_noners  4r cbeZdZdZefdZdZeedZedZdS)rawA wrapper around a function to catch exceptions and dispatch to a handler. This is like a functional try/except block, in the same way that ifexprs are functional if/else blocks. Examples -------- >>> excepting = excepts( ... ValueError, ... lambda a: [1, 2].index(a), ... lambda _: -1, ... ) >>> excepting(1) 0 >>> excepting(3) -1 Multiple exceptions and default except clause. >>> excepting = excepts((IndexError, KeyError), lambda a: a[0]) >>> excepting([]) >>> excepting([1]) 1 >>> excepting({}) >>> excepting({0: 1}) 1 c0||_||_||_dSrF)rr%handler)rDrr%rs rrCzexcepts.__init__s  r cv |j|i|S#|j$r}||cYd}~Sd}~wwxYwrF)r%rr)rDr&r$es rrzexcepts.__call__s^ #49d-f-- -x # # #<<?? " " " " " " #s  8388rcFddlm}|j} t|tr4ddt td|z}n|j}|d ||S#t$rt|j cYSwxYw)Nr)dedentz(%s)z, rPal A wrapper around {inst.func.__name__!r} that will except: {exc} and handle any exceptions with {inst.handler.__name__!r}. Docs for {inst.func.__name__!r}: {inst.func.__doc__} Docs for {inst.handler.__name__!r}: {inst.handler.__doc__} )instr) textwraprrr,r-rmaprrPrrrIrK)rDrrexc_names rrKzexcepts.__doc__ s######h &#u%% (!DII :..44%%<6   f   & & &::% % % % &sA/A??B B c|j} t|tr1dt t d|}n|j}|jjd|S#t$rYdSwxYw)N_or_rP _excepting_ excepting) rr,r-rr rrPr%r)rDrr s rrPzexcepts.__name__+sh #u%% (!;;s:j+A+A3'G'GHH<(, (:(:(:HHE E   ;; sAA'' A54A5N) rPrQrRrKrrCrr>rBrr rrrs6+6 ### w'''&&('&>  X   r rcb|6 tj|}n #ttf$r }|}Yd}~nd}~wwxYwt |trd||fSt |tjs>|t jvr.t|drt|j dr ||}d|fSdS|dfS)NrwrG)NF) rdre ValueErrorr"r, Signaturer signaturesrVrw)rr% builtin_func builtin_argsrr/s r_check_sigspecr8s '--GGI&   GGGGGG ':&& \\<000 !2 3 3  E$ $ o.. D. ::  , -C9 { D=s616cN|tjvr ||}d|fSt|||g|RSrF)rr_check_sigspec_orig)rr%rrr/s rrrQsB 5# # , -C9 "7D,NNNNNr z Private function to aid in introspection compatibly across Python versions. If a callable doesn't have a signature (Python 3) or an argspec (Python 2), the signature registry in toolz._signatures is used. ct||tj|\}}||Std|jDS)Nc3`K|])}|j|ju|j|j|jfv%dV*dS)r N)rarnrbPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYrps rrz$num_required_args..fsgKKQ)qw&K6a5q7HIIKqKKKKKKr )rr_num_required_argssumrcrhr%rrvs rnum_required_argsr#asr $0H!%''KGR KK',3355KKK K KKr ct||tj|\}}||Std|jDS)Nc36K|]}|j|jkVdSrF)rbrjrs rrzhas_varargs..os@55v))555555r )rr _has_varargsanyrcrhr!s rrrksf $0BDIIKGR 55*1133555 5 55r ct||tj|\}}||Std|jDS)Nc3\K|]'}|j|jup|j|j|jfvV(dSrF)rarnrbrmrkrs rrzhas_keywords..wsW55y'<&Q^Q];;555555r )rr _has_keywordsr'rcrhr!s rrrssf $0CTJJKGR 55*1133555 5 55r ct||tj|||\}}||S |j|i|n#t$rYdSwxYwdSr)rr_is_valid_argsrr"r%r&r$rr"s rrr|sx $0D!%tV55KGR  d%f%%%% uu 4 5 AAct||tj|||\}}||S |j|i|n#t$rYdSwxYwdSr)rr_is_partial_args bind_partialr"r-s rrfrfsy $0F!%tV55KGR d-f---- uu 4r.ct||tj||\}}||St||}| ||k}|sdSt ||}|rdSt ||}|rdS|||dSdS)aM Does a function have only n positional arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x): ... return x >>> is_arity(1, f) True >>> def g(x, y=1): ... return x + y >>> is_arity(1, g) False NFT)rr _is_arityr#rr)nr%rr"numvarargsrUs rrrs!$DIIKGR D' * *C Qh 5$((GuD'**Hu gt 4r aY Number of required positional arguments This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x, y, z=3): ... return x + y + z >>> num_required_args(f) 2 >>> def g(*args, **kwargs): ... pass >>> num_required_args(g) 0 aW Does a function have variadic positional arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(*args): ... return args >>> has_varargs(f) True >>> def g(**kwargs): ... return kwargs >>> has_varargs(g) False z Does a function have keyword arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x, y=0): ... return x + y >>> has_keywords(f) True a Is ``func(*args, **kwargs)`` a valid function call? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def add(x, y): ... return x + y >>> is_valid_args(add, (1,), {}) False >>> is_valid_args(add, (1, 2), {}) True >>> is_valid_args(map, (), {}) False **Implementation notes** Python 2 relies on ``inspect.getargspec``, which only works for user-defined functions. Python 3 uses ``inspect.signature``, which works for many more types of callables. Many builtins in the standard library are also supported. aj Can partial(func, *args, **kwargs)(*args2, **kwargs2) be a valid call? Returns True *only* if the call is valid or if it is possible for the call to become valid by adding more positional or keyword arguments. This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def add(x, y): ... return x + y >>> is_partial_args(add, (1,), {}) True >>> is_partial_args(add, (1, 2), {}) True >>> is_partial_args(add, (1, 2, 3), {}) False >>> is_partial_args(map, (), {}) True **Implementation notes** Python 2 relies on ``inspect.getargspec``, which only works for user-defined functions. Python 3 uses ``inspect.signature``, which works for many more types of callables. Many builtins in the standard library are also supported. ) _signaturesrO)NNrF)3 functoolsrrrdsysoperatorrr importlibrtypesr utilsr rV version_infoPYPY__all__rrrrr>rBr?objectrrrrrrrrrrrrrrrrKr#rrrrfrr7rrr rrCs%%%%%%%% %%%%%%%%######ws'((DS-=a-@1-D 'ws'((   !!!"...D$-$-$-N////:'''''x'''(O%O%O%O%O%FO%O%O%d   MMMM`T8T8T8T8T8fT8T8T8n4%%%*2    6B   44 QQQQQfQQQh,O(OOOKKKK55555555        D     0:#"""""""r