HtjfdZddlmZddlmZmZmZddlm Z m Z  ddl m Z ddl m Z n#e$rddlm Z ddlm Z YnwxYwddlmZddlmZdd lZdd lZdd lZejeZdd lZdd lZdd lZdd lZdd lZer dd l Z n#e$rd Z d Z!YnwxYwdd l Z dd l"Z"e rdd l#Z# dd l$Z$n #e$rd Z$YnwxYwdd l%Z%dd l&Z&dd l'm(Z(dd l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6dd l7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?ddlm@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPgdZQeRejeFrejSnejTddzZUgdZVddgZWddl=mXZXdZYeGdZZeGdZ[eRej\]dpdZ^Gdde_Z`eFr'ejajbZcedecejajegZfdZgndZg dnd!Zhd"Zid#ZjejZk dd$llmmZjn #e$rYnwxYwdod&Zndpd(Zoe dpd)Zod*ZpeFrd+Zqd,Zrndd-lmsZsmtZtd.Zqd/Zre@eqd0e@erd1d2Zud3Zvd4Zwd5ZxeGd6Zydqd7Zzd8Z{d9Z|e|}d:Z~d;Zd<Zd=ZeGd>Zd?ZdrdAZdsdBZeFrdsdCZndsdDZe@edEe8dFdGHdtdIZeddJZeddKZedddLgZdudNZdOZ ddPlmZdQZd6Ze$r)ePr'dRejcxkrdSkrnne$jZdQZnddTlmZeZd ZeGdUZeFr#dQZ edVdWn#e$rd ZYnYnxYwdXZndQZdYZn#e$rd Zd Zd Zd Zd ZdZZYnwxYwe@ed[d\Ze%jZeZd]Z ejd^dQZn #e$rd ZYnwxYwdqd_ZerejZnejeZd`ZdaZdbZe8dGdcddedfefdgZdhZdiZdjZdkZdlZdmZd S)vz4passlib.utils -- helpers for writing password hashes)JYTHON) b2a_base64 a2b_base64Error) b64encode b64decode)Sequence)Iterable)lookup)update_wrapperNznot present under Jython)warn) BASE64_CHARS AB64_CHARS HASH64_CHARS BCRYPT_CHARS Base64EngineLazyBase64Engineh64h64bigbcrypt64 ab64_encode ab64_decode b64s_encode b64s_decode)deprecated_functiondeprecated_methodmemoized_property classproperty hybrid_method)ExpectedStringErrorExpectedTypeError)add_doc join_bytesjoin_byte_valuesjoin_byte_elemsirangeimapPY3u join_unicodeunicodebyte_elem_value nextgetterunicode_or_strunicode_or_bytes_typesget_method_functionsuppress_causePYPY)rsys_bitsunix_crypt_schemesrounds_cost_valuesconsteqsaslprep xor_bytes render_bytes is_same_codec is_ascii_safeto_bytes to_unicode to_native_str has_crypt test_crypt safe_crypttickrng getrandbytes getrandstrgenerate_passwordis_crypt_handleris_crypt_contexthas_rounds_info has_salt_infog?) sha512_crypt sha256_crypt sha1_cryptbcrypt md5_crypt bsdi_crypt des_cryptlinearlog2)MissingBackendError PASSLIB_MAX_PASSWORD_SIZEic<eZdZdZdZdZdZdZdZdZ dZ d S) SequenceMixinz helper which lets result object act like a fixed-length sequence. subclass just needs to provide :meth:`_as_tuple()`. c td)Nzimplement in subclass)NotImplementedErrorselfs T/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/passlib/utils/__init__.py _as_tuplezSequenceMixin._as_tuples!"9:::rVcDt|SN)reprrar^s r`__repr__zSequenceMixin.__repr__DNN$$%%%rVc6||Srcra)r_idxs r` __getitem__zSequenceMixin.__getitem__s~~$$rVcDt|Src)iterrar^s r`__iter__zSequenceMixin.__iter__rfrVcDt|Src)lenrar^s r`__len__zSequenceMixin.__len__s4>>##$$$rVc2||kSrcrhr_others r`__eq__zSequenceMixin.__eq__s~~5((rVc.|| Src)rtrrs r`__ne__zSequenceMixin.__ne__s;;u%%%%rVN) __name__ __module__ __qualname____doc__rarerjrmrprtrvrVr`r[r[s;;;&&&%%%&&&%%%)))&&&&&rVr[ctjt|j}|sdS||}|r|jt vrdS|t|djtkS)*test if function accepts specified keywordFT) inspect signaturer0 parametersgetkind _VAR_ANY_SETlist _VAR_KEYWORD)funckeyparamsargs r`accepts_keywordrsq"#6t#<#<==H 5jjoo  38<//4d6ll2&', <z'update_mixin_classes..s-==t:dE**======rVrN) isinstancetyper __bases__removeany enumeraterroreversedinserttuple) targetaddrappendbeforeafterdryrunbasesrirend_idxrs @r`update_mixin_classesrs<#te ! " "E$ fd # # XF $ $E u||~~ U### % % %E====u=====  !*5!1!1 % %IC!%..*T6":":e**C %.x%?%?MGT!$..!%jj72$SU|t3333  C LLe $ $ $ $ ( <<((rVc#K|dkrtdt|tr4t|}d}||kr||z}|||V|}||kdSdSt|tr`t |} t j||} t|}n#t$rYdSwxYwt j |f|VPtd)z8 split iterable into chunks of elements. rzsize must be positive integerrTzsource must be iterableN) ValueErrorrr ror rl itertoolsislicenext StopIterationchain TypeError)sourcesizeendinitr chunk_itrfirsts r`batchrs axx8999&(##3&kk #ggDA1+   A#gggggg FH % % 36ll 7!(d33I Y     /5(I66 6 6 6  71222sB,, B:9B:c0t|tr't|tstdd}nPt|tr,t|tstdt}ntdt |t |k}|r|}d}|s|}d}|rt ||D] \}}|||z z}n8t ||D]'\}}|t|t|z z}(|dkS)aCheck two strings/bytes for equality. This function uses an approach designed to prevent timing analysis, making it appropriate for cryptography. a and b must both be of the same type: either str (ASCII only), or any type that supports the buffer protocol (e.g. bytes). Note: If a and b are of different lengths, or if an error occurs, a timing attack could theoretically reveal information about the types and lengths of a and b--but not their values. z)inputs must be both unicode or both bytesFrr)rr+rbytesr(rozipord)leftright is_py3_bytes same_sizetmpresultlrs r`r6r6;sE*$  E%)) IGHH H D% E%'' IGHH H CDDD Tc%jj(I &sE??  CAa a!eOFF sE?? & &CAa c!ffs1vvo %FF Q;rV)compare_digest,c|}||r |dd}|sgSd||DS)zRsplit comma-separated string into list of elements, stripping whitespace. Nr~c6g|]}|Sr{)striprelems r` zsplitcomma..s 9 9 9dTZZ\\ 9 9 9rV)rendswithsplit)rseps r` splitcommars_\\^^F s  9 9fll3&7&7 9 9 99rVvaluec2t|tstdt|tjtjtfd|D}tj d|}|stStj }||dr0||dstd|ztj }n|}tj}tj}tj}tj}tj} tj} tj} tj} tj} |D]O}|r Jd|r Jd||rtd |z||rtd |z||rtd |z||rtd |z| |rtd |z| |rtd|z| |rtd|z| |rtd|z| |rtd|z||rtd|zQ|S)aNormalizes unicode strings using SASLPrep stringprep profile. The SASLPrep profile is defined in :rfc:`4013`. It provides a uniform scheme for normalizing unicode usernames and passwords before performing byte-value sensitive operations such as hashing. Among other things, it normalizes diacritic representations, removes non-printing characters, and forbids invalid characters such as ``\n``. Properly internationalized applications should run user passwords through this function before hashing. :arg source: unicode string to normalize & validate :param param: Optional noun identifying source parameter in error messages (Defaults to the string ``"value"``). This is mainly useful to make the caller's error messages make more sense contextually. :raises ValueError: if any characters forbidden by the SASLPrep profile are encountered. :raises TypeError: if input is not :class:`!unicode` :returns: normalized unicode string .. note:: This function is not available under Jython, as the Jython stdlib is missing the :mod:`!stringprep` module (`Jython issue 1758320 `_). .. versionadded:: 1.6 z"input must be unicode string, not c3VK|]#}| |rtn|V$dSrc)_USPACE)rc in_table_b1 in_table_c12s r`rzsaslprep..sV  {1~~ <??)      rVNFKCrr~zmalformed bidi sequence in z$failed to strip B.1 in mapping stagez(failed to replace C.1.2 in mapping stagez$unassigned code points forbidden in z control characters forbidden in z$private use characters forbidden in z"non-char code points forbidden in zsurrogate codes forbidden in z!non-plaintext chars forbidden in z!non-canonical chars forbidden in z1display-modifying / deprecated chars forbidden inztagged characters forbidden in zforbidden bidi character in )rr+rr stringpreprrr* unicodedata normalize_UEMPTY in_table_d1r in_table_d2 in_table_a1in_table_c21_c22 in_table_c3 in_table_c4 in_table_c5 in_table_c6 in_table_c7 in_table_c8 in_table_c9)rparamdata is_ral_charis_forbidden_bidi_charrrrrrrrrrrrrs @@r`r7r7s4X fg & &)if()) ) *L(K           D   . .D (K{47-{48$$ D:UBCC C!+!7"-(K!2(K(K(K(K(K(K(K EE;q>>II#III!<??NN$NNN" ;q>> MCeKLL L  A   I?%GHH H ;q>> MCeKLL L ;q>> KAEIJJ J ;q>> F> J@5HII I ;q>> J@5HII I ;q>> 5,.3455 5 ;q>> H>FGG G " !! $ $ E;eCDD D E KrVc0tdtz)zstub for saslprep()z>saslprep() support requires the 'stringprep' module, which is )r]_stringprep_missing_reason)rrs r`r7r7s%!#02L#MNN NrVct|tr|d}|td|Dz}|dS)aPeform ``%`` formating using bytes in a uniform manner across Python 2/3. This function is motivated by the fact that :class:`bytes` instances do not support ``%`` or ``{}`` formatting under Python 3. This function is an attempt to provide a replacement: it converts everything to unicode (decoding bytes instances as ``latin-1``), performs the required formatting, then encodes the result to ``latin-1``. Calling ``render_bytes(source, *args)`` should function roughly the same as ``source % args`` under Python 2. .. todo:: python >= 3.5 added back limited support for bytes %, can revisit when 3.3/3.4 is dropped. latin-1c3nK|]0}t|tr|dn|V1dS)rN)rrdecode)rrs r`rzrender_bytes..,sZ66),6@U5K5K%CJJy111!$666666rV)rrrrencode)rrrs r`r9r9sk &%  *y)) e6604666666F == # ##rVc8t|dSNbig)int from_bytesrs r` bytes_to_intr2s~~eU+++rVc.||dSr)r<rcounts r` int_to_bytesr4s~~eU+++rV)hexlify unhexlifyc<tt|dS)N)rrrs r`rr9s75>>"%%%rVc2td|dzz|zS)Nz%%0%dxr)rrs r`rr;s(eQh/58999rVz/decode byte string as single big-endian integerz/encode integer as single big-endian byte stringcvtt|t|z t|S)z;Perform bitwise-xor of two byte strings (must be same size))rrrorrs r`r8r8As-  T**\%-@-@@#d)) L LLrVcLd|dz t|zz}||zd|S)zE repeat or truncate string, so it has length rN)rorrmults r` repeat_stringr Es0 qS[[( (D TM5D5 !!rVcXd|dz t|zz}t||z|S)zN variant of repeat_string() which truncates to nearest UTF8 boundary. r)ro utf8_truncater s r`utf8_repeat_stringrMs1 qS[[( (D $ - --rVct|}||kr0|#t|trtnt}||||z zzS|d|S)z>right-pad or truncate string, so it has length N)rorr+_UNULL_BNULL)rrpadcurs r`right_pad_stringrXsT f++C czz ;&vw77C&&VCc48n$$ete}rVcttsttdt}|dkrt d||z}||krSt |dz|}||kr(t |dzdkrn|dz }||k(||ksJd|fd}|sJS) a helper to truncate UTF8 byte string to nearest character boundary ON OR AFTER . returned prefix will always have length of at least , and will stop on the first byte that's not a UTF8 continuation byte (128 - 191 inclusive). since utf8 should never take more than 4 bytes to encode known unicode values, we can stop after ``index+3`` is reached. :param bytes source: :param int index: :rtype: bytes rrrNc d}n#t$rYdSwxYw|dsJdS)Nutf-8T)rUnicodeDecodeError startswith)textrrs r` sanity_checkz#utf8_truncate..sanity_checksh ==))DD!   44  v}}W5566666ts  '')rrr!romaxminr,)rindexrr rs` @r`r r cs2 fe $ $9x888 f++C qyyAus{## ||  eai  C #++ 6%= ) )D 0D 8 8    #++||||FUF^F       <>>> MrVs aA:#!asciicHt|tkS)zRTest if codec is compatible with 7-bit ascii (e.g. latin-1, utf-8; but not utf-16))_ASCII_TEST_UNICODEr_ASCII_TEST_BYTES)codecs r`is_ascii_codecr)s  % %e , ,0A AArVcr||krdS|r|sdSt|jt|jkS)z3Check if two codec names are aliases for same codecTF) _lookup_codecnamers r`r:r:sE u}}t Uu    #}U';';'@ @@rVr€ct|trtntt fd|DS)z.s'%%q1u%%%%%%rV)rr_B80_U80all)rrs @r`r;r;s>65))3tA %%%%f%%% % %%rVrc |sJt|tr<|r8t||s(|||S|St|t r||St ||)aHelper to normalize input to bytes. :arg source: Source bytes/unicode to process. :arg encoding: Target encoding (defaults to ``"utf-8"``). :param param: Optional name of variable/noun to reference when raising errors :param source_encoding: If this is specified, and the source is bytes, the source will be transcoded from *source_encoding* to *encoding* (via unicode). :raises TypeError: if source is not unicode or bytes. :returns: * unicode strings will be encoded using *encoding*, and returned. * if *source_encoding* is not specified, byte strings will be returned unchanged. * if *source_encoding* is specified, byte strings will be transcoded to *encoding*. )rrr:rrr+r )rencodingrsource_encodings r`r<r<s4 OO8&%  1  =(#K#K ==1188BB BM FG $ $1}}X&&&!&%000rVc|sJt|tr|St|tr||St ||)aHelper to normalize input to unicode. :arg source: source bytes/unicode to process. :arg encoding: encoding to use when decoding bytes instances. :param param: optional name of variable/noun to reference when raising errors. :raises TypeError: if source is not unicode or bytes. :returns: * returns unicode strings unchanged. * returns bytes strings decoded using *encoding* )rr+rrr rr4rs r`r=r=sX$ OO8&'""1 FE " "1}}X&&&!&%000rVct|tr||St|tr|St ||rc)rrrr+r r7s r`r>r>sM fe $ $ 5==** *  ( ( 5M%fe44 4rVct|tr|St|tr||St ||rc)rrr+rr r7s r`r>r>sM fe $ $ 5M  ( ( 5==** *%fe44 4rVa>Take in unicode or bytes, return native string. Python 2: encodes unicode using specified encoding, leaves bytes alone. Python 3: leaves unicode alone, decodes bytes using specified encoding. :raises TypeError: if source is not unicode or bytes. :arg source: source unicode or bytes string. :arg encoding: encoding to use when encoding unicode or decoding bytes. this defaults to ``"utf-8"``. :param param: optional name of variable/noun to reference when raising errors. :returns: :class:`str` instance z1.6z1.7) deprecatedremovedc&t||dS)z'deprecated, use to_native_str() insteadhash)r)r>)rr4s r` to_hash_strr>$s  8 8 88rVz true t yes y on 1 enable enabledz#false f no n off 0 disable disablednonebooleancD|dvsJt|tr\|}|tvrdS|t vrdS|t vr|Std|d|t|tr|S||St|S)z\ helper to convert value to boolean. recognizes strings such as "true", "false" )TFNTFz unrecognized z value: ) rr/lowerr _true_set _false_set _none_setrbool)rr?rcleans r`as_boolrH-s & & & & &%/00 ##%% I  4 J  5 I  KjuuEFFF E4   E{{rVctst|tsdS |ddS#t$rYdSwxYw)z UT helper -- test if value is safe to pass to crypt.crypt(); under PY3, can't pass non-UTF8 bytes to crypt.crypt. TrF)crypt_accepts_bytesrrrrrs r`is_safe_crypt_inputrKGs` *UE":":t Wt uus7 AA)cryptT)rKr)rMrr) nullcontextz*:!xxc4trmt|tr|d}t|vrt dt|tr|d}nt|t rM|} |d}n#t$rYdSwxYw|d|ks Jdt|vrt dt|t r|d} t5t||}dddn #1swxYwYn#t$rYdSwxYwt|t r|d}|r|dtvrdS|S)Nrnull character in secretr$z"utf-8 spec says this can't happen!r)rJrr+rrrrrr_NULL_safe_crypt_lock_cryptOSError_invalid_prefixes)secretr=origrs r`rArAs" 0fg..4#]]733FV##$%?@@@dG,,0;;w//D fe,, E!D$!'w!7!7-$$$#tt$"==11T999 D:99F??$%?@@@dE**0;;w//D %22#FD11F222222222222222   tt  &%(( 0w// VAY*;;;tMsH B## B10B1E !D>2 E >EE EE EEct|tr|d}t|vrt dt|tr|d}t 5t ||}dddn #1swxYwY|sdS|d}|dtvrdS|S)NrrRr$r) rr+rrSrrTrUrrW)rXr=rs r`rArAs&'** 0w// !;<<<$(( ,{{7++! . .-- . . . . . . . . . . . . . . . t]]7++Fay---tMs4BBBcdSrcr{rXr=s r`rArA]strVaWrapper around stdlib's crypt. This is a wrapper around stdlib's :func:`!crypt.crypt`, which attempts to provide uniform behavior across Python 2 and 3. :arg secret: password, as bytes or unicode (unicode will be encoded as ``utf-8``). :arg hash: hash or config string, as ascii bytes or unicode. :returns: resulting hash as ascii unicode; or ``None`` if the password couldn't be hashed due to one of the issues: * :func:`crypt()` not available on platform. * Under Python 3, if *secret* is specified as bytes, it must be use ``utf-8`` or it can't be passed to :func:`crypt()`. * Some OSes will return ``None`` if they don't recognize the algorithm being used (though most will simply fall back to des-crypt). * Some OSes will return an error string if the input config is recognized but malformed; current code converts these to ``None`` as well. ct|tsJdt|z|s Jdt|||kS)zcheck if :func:`crypt.crypt` supports specific hash :arg secret: password to test :arg hash: known hash of password to use as reference :returns: True or False z#hash must be unicode_or_str, got %szhash must be non-empty)rr.rrAr\s r`r@r@s_ dN + +;;-T :;; + )))))4 fd # #t ++rVctjd|}|r?td|ddDSdS)zhelper to parse version stringz(\d+(?:\.\d+)+)c34K|]}t|VdSrc)rrs r`rz parse_version..s(AA4SYYAAAAAArVr.N)researchrgroupr)rms r` parse_versionresW $f--ABAA1771::+;+;C+@+@AAAAAA 4rVrc ddlm}t|drKt|dr; |}n%#t$r|d}YnwxYwt d|ttdrtjndtttj ttr'tjd d ndfz}t!||d d S) z.generate prng seed value from system resourcesr)sha512getstate getrandbitsiz%s %s %s %.15f %.15f %sgetpidN rrr)hashlibrghasattrrhr]rir)osrjidobjecttimerB has_urandomurandomrrr hexdigest)rrgrs r`genseedrus6uj!!/ge]&C&C/ /NN$$EE" / / /%%g..EEE / & ' ' r8,,6 $ 688   -8> 2i(((Q#+  D( vvdkk'**++5577 < <.helperMs_q)) %ii$,    aKE FA%iiiiiirV)_BEMPTYr$)rCrrys`` r`rDrDBsG  FFHH % %%rVc(dkrtdtdkrtddkrzSfd}ttrt |St |S)z|return string containing *count* number of chars/bytes, whose elements are drawn from specified charset, using specified rngrzcount must be >= 0zalphabet must not be emptyrc3Kdz}d}|kr|zV|z}|dz }|kdSdS)Nrr) randrange)rrcharsetrlettersrCs r`ryzgetrandstr..helperfsg a%00 %ii%'/* * * * g E FA%iiiiiirV)rrorr+r*r%)rCr~rryrs``` @r`rErEWs  qyy-...'llG!||5666!||'7##)FFHH%%%vvxx(((rV42346789ABCDEFGHJKMNPQRTUVWXYZabcdefghjkmnpqrstuvwxyzz2.0z/passlib.pwd.genword() / passlib.pwd.genphrase())r:r; replacement c.tt||S)awgenerate random password using given length & charset :param size: size of password. :param charset: optional string specified set of characters to draw from. the default charset contains all normal alphanumeric characters, except for the characters ``1IiLl0OoS5``, which were omitted due to their visual similarity. :returns: :class:`!str` containing randomly generated password. .. note:: Using the default character set, on a OS with :class:`!SystemRandom` support, this function should generate passwords with 5.7 bits of entropy per character. )rErC)rr~s r`rFrFvs, c7D ) ))rV)r, setting_kwds context_kwdsverifyr=identifycDtfdtDS)z4check if object follows the :ref:`password-hash-api`c38K|]}t|VdSrcrmrr,objs r`rz#is_crypt_handler..-==dwsD!!======rV)r2_handler_attrsrs`r`rGrG( ====n=== = ==rV) needs_update genconfiggenhashrencryptrcDtfdtDS)zOcheck if object appears to be a :class:`~passlib.context.CryptContext` instancec38K|]}t|VdSrcrrs r`rz#is_crypt_context..rrV)r2_context_attrsrs`r`rHrHrrVc:d|jvot|ddduS)z_check if handler provides the optional :ref:`rounds information ` attributesrounds min_roundsNrgetattrhandlers r`rIrIs+ , , = G\4 0 0 <>rVc:d|jvot|ddduS)z[check if handler provides the optional :ref:`salt information ` attributessalt min_salt_sizeNrrs r`rJrJs- g* * @ G_d 3 34 ?ArV)NNFNNF)rrrc)rrN)rr)r$)Nr@)rzpasslib.utils.compatrbinasciirrr_BinAsciiErrorbase64rrcollections.abcr r ImportError collectionscodecsr r+ functoolsr rrlogging getLoggerrwlogmathrnsysrandomrarrrqr threadingtimeittypeswarningsr passlib.utils.binaryrrrrrrrrrrrrrpasslib.utils.decorrrrrr passlib.excr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2__all__rmaxsizemaxintr3r4r5rUrzrrenvironrMAX_PASSWORD_SIZErpr[ Parameter VAR_KEYWORDrsetVAR_POSITIONALrrrrr6 str_consteqhmacrrr7r9rrrrr8r rrrrr r'rr&r)r:r0r1r;r<r=r>r>rrCrDrErHrKrLrUr?rSpypy_version_infoLockrTcrypt_needs_lockrNrWrJrrAr@ default_timertimerrBrersrrr]ru SystemRandomrCRandomrDrE _52charsetrFrrGrrHrIrJr{rVr`rs ::('''''DDDDDDDDDD''''''''%(((((((((((((%%%$$$$$$$$$$$$$$%+*****$$$$$$'g'11  @ @@@ %?"""@  III  ?>>>>>>>MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM ' ' ' \ 3xtxs:  A>>D E E ),+++++  !B%% !C&&C 'BCCKtLL &&&&&F&&&4=$0L3 g&7&FGHHL = = = ==== @E9>R(R(R(R(n333>888|  .......   D  : : : :}}}}@NNNN$$$, :,,,,,,,,+++++++&&&::: GHHH GHHHMMM"""...  6AAAL('..w77BBBAAAqyy&&& #1#1#1#1J111145555555555    *u555999659 C288:: ; ; S6<<>> ? ? CV   4   s%%%%%%I E !T !i3+@MMMMIMMMMM*9>++  544444&;== % P #  F7D ! ! ! ! ( ( ("'     D+ + + + ^#    G FI f    < , , ,  ,BJqMMMKKKKK====B# &   CC &- " "C &&&*))):D u!RTTTz***TT*2  >>>   >>>>>> AAAAAsx )==?B BB"B''B10B1G&&G.-G.M= M$$M0-M0=NN1OO O