gSrSSKJr SSKJrJrJr SSKJ r J r SSK J r SSK J r SSKJr SSKJr SS KrSS KrSS Kr\R0"\5rSS KrSS KrSS KrSS KrSS Kr\(aSS K r OSS K r SS K"r"\ (aSS K#r#SS K$r$SS K%r%SS K&r&SS K'J(r( SS K)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6 SS K7J8r8J9r9J:r:J;r;Jr>J?r? SSKJ@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrP /SQrQ\R"\R4"\F(a \RO \RS5S-5rU/SQrVSS/rWSSK=JXrX SrY\G"S5rZ\G"S5r[\R"\RRS5=(d S5r^"SS\_5r`\F(a8\RRrc\d"\c\RR/5rfSrgOSrgSjS!jrhS"riS#rj\jrkSS$KlJmrj SkS%jrnSlS&jro\ cSlS'jroS(rp\F(aS)rqS*rrOSS+KJsrsJtrt S,rqS-rr\@"\qS.5 \@"\rS/5 S0ruS1rvS2rwS3rx\G"S45rySmS5jrzS6r{S7r|\|RS85r~S9rS:rS;r\G"S<5rS=rSnS>jrSoS?jr\F(aSoS@jrOSoSAjr\@"\SB5 \8"SCSDSE9SpSFj5r\d"SGGR55r\d"SHGR55r\d"SSI/5rSqSJjrSKrSSLKJr SMrS4r\$(a7\P(a0SN\GR$s=::aSO::aO O\$GR&"5rSMrOSSPKJr \"5rS r\G"SQ5r\F(aSMr\"SRSS5 STrOSMrSUr\@"\SW5 SXr\%GR8r\rSYr\GR@"SZ5 SMrSmS[jr\(a\GRH"5rO\GRL"\"55rS\rS]rS^r\8"SDS_S`Sa9Sb\4Scj5rSdrSerSfrSgrShrSirg !\a SSKJ r SSKJ r GNf=f!\a S r S r!GNf=f!\a S r$GNf=f!\a GNMf=f!\a S rN N=f!\a S rS rS rS rS rSVrGNf=f!\a S rNf=f)rz4passlib.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_SIZEicB\rSrSrSrSrSrSrSrSr Sr S r S r g ) SequenceMixinzw helper which lets result object act like a fixed-length sequence. subclass just needs to provide :meth:`_as_tuple()`. c[S5e)Nzimplement in subclass)NotImplementedErrorselfs O/home/matz/Project1/venv/lib/python3.13/site-packages/passlib/utils/__init__.py _as_tupleSequenceMixin._as_tuples!"9::rVc4[UR55$N)reprrbr_s ra__repr__SequenceMixin.__repr__DNN$%%rVc(UR5U$rerb)r`idxs ra __getitem__SequenceMixin.__getitem__s~~$$rVc4[UR55$re)iterrbr_s ra__iter__SequenceMixin.__iter__rirVc4[UR55$re)lenrbr_s ra__len__SequenceMixin.__len__s4>>#$$rVc(UR5U:H$rerkr`others ra__eq__SequenceMixin.__eq__s~~5((rVc.URU5(+$re)rzrxs ra__ne__SequenceMixin.__ne__s;;u%%%rVN) __name__ __module__ __qualname____firstlineno____doc__rbrgrmrqrurzr}__static_attributes__rrVrar[r[s*;&%&%)&rVr[c[R"[U55RnU(dgUR U5nU(aUR [ ;agU[U5SR [:H$)*test if function accepts specified keywordFT) inspect signaturer0 parametersgetkind _VAR_ANY_SETlist _VAR_KEYWORD)funckeyparamsargs raaccepts_keywordrsa""#6t#<=HHjjo 388</d6l2&',, <# UHn[UT5v M g7fre) issubclass).0basemixins ra 'update_mixin_classes..s=ut:dE**urN) isinstancetyper __bases__removeany enumeraterrtreversedinserttuple) targetaddrappendbeforeafterdryrunbasesrlrend_idxrs @raupdate_mixin_classesrsO<#te !! "E fd # #XFEu|~ U#  E=u===!*5!1IC!%..v*T":": "2e*C%.x%?MG!$..!%j72$U|t333 &@C LLe $?D  < rVc## US:a [S5e[U[5(a'[U5nSnX2:aX1-nXUv UnX2:aMgg[U[5(aJ[ U5n[ R"XQ5n[U5n[ R"U4U5v M>[S5e![a gf=f7f)z0 split iterable into chunks of elements. rzsize must be positive integerrzsource must be iterableN) ValueErrorrr rtr rp itertoolsislicenext StopIterationchain TypeError)sourcesizeendinitr chunk_itrfirsts rabatchrs ax899&(##&k gA1+ Ag FH % %6l!((3I Y//5(I6 6 122 !  s0A C 9C  B:'C : CC CC c[U[5(a#[U[5(d [S5eSnOG[U[5(a'[U[5(d [S5e[nO [S5e[ U5[ U5:HnU(aUnSnU(dUnSnU(a![ WU5H upgWXg- -nM WS:H$[ WU5HupgW[U5[U5- -nM! WS:H$)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(rtzipord)leftright is_py3_bytes same_sizetmpresultlrs rar6r6;s*$  %))GH H D% %''GH H CDD Tc%j(I sE?CA aeOF# Q;sE?CA c!fs1vo %F# Q;rV)compare_digestcUR5nURU5(aUSSnU(d/$URU5Vs/sHo"R5PM sn$s snf)zJsplit comma-separated string into list of elements, stripping whitespace. Nr)stripendswithsplit)rsepelems ra splitcommarsX\\^F s  &,ll3&7 9&7dZZ\&7 99 9sA$c\^^[U[5(d[S[U5<35e[R m[R m[UU4SjU55n[R"SU5nU(d[$[RnU"US5(a/U"US5(d[SU-5e[RnOUn[Rn[Rn[R n[R"n[R$n [R&n [R(n [R*n [R,n UGH:nT"U5(aS5eT"U5(aS5eU"U5(a[S U-5eU"U5(a[S U-5eU"U5(a[S U-5eU"U5(a[S U-5eU "U5(a[S U-5eU "U5(a[SU-5eU "U5(a[SU-5eU "U5(a[SU-5eU "U5(a[SU-5eU"U5(dGM/[SU-5e U$)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 c3l># UH)nT"U5(aMT"U5(a[OUv M+ g7fre)_USPACE)rc in_table_b1 in_table_c12s rarsaslprep..s. A1~ *<??)s44NFKCrrzmalformed 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 @@rar7r7sX fg & &f() ) **L((K    D   .D ((K4748$$:UBC C!+!7!7"-((K!22((K((K((K((K((K((K((K q>>I#II!??N$NN" q>>CeKL L A  ?%GH H q>>CeKL L q>>AEIJ J q>>>@5HI I q>>@5HI I q>>,.345 5 q>>>FG G "! $ $;eCD D=@ KrVc&[S[-5e)zstub for saslprep()z>saslprep() support requires the 'stringprep' module, which is )r^_stringprep_missing_reason)rrs rar7r7s!#02L#MN NrVc[U[5(aURS5nU[SU55-nUR S5$)atPeform ``%`` 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-1c3r# UH-n[U[5(aURS5OUv M/ g7f)rN)rrdecode)rrs rarrender_bytes..,s56046@U5K5KCJJy1!$%04s57)rrrrencode)rrrs rar9r9sL &%  y) e604666F == ##rVc.[RUS5$Nbig)int from_bytesvalues ra bytes_to_intr2s~~eU++rVc&URUS5$r)r<rcounts ra int_to_bytesr 4s~~eU++rV)hexlify unhexlifyc,[[U5S5$)N)rr rs rarr9s75>"%%rVc*[SUS--U-5$)Nz%%0%dxr)r rs rar r ;s(eQh/5899rVz/decode byte string as single big-endian integerz/encode integer as single big-endian byte stringcV[[U5[U5- [U55$)z;Perform bitwise-xor of two byte strings (must be same size))r rrtrrs rar8r8As"  T*\%-@@#d) LLrVc8SUS- [U5--nX-SU$)z= repeat or truncate string, so it has length rN)rtrrmults ra repeat_stringrEs* qS[( (D M5D !!rVcFSUS- [U5--n[X-U5$)zF variant of repeat_string() which truncates to nearest UTF8 boundary. r)rt utf8_truncaters rautf8_repeat_stringrMs* qS[( (D  --rVc[U5nX:a-Uc![U[5(a[O[nXX- --$USU$)z>right-pad or truncate string, so it has length N)rtrr+_UNULL_BNULL)rrpadcurs raright_pad_stringr XsC f+C z ;&vw77&VC48n$$et}rVcP^^[T[5(d[T[S5e[T5nUS:a[ SX-5nX:aT$[ US-U5nX:a"[ TU5S-S:waOUS- nX:aM"X:XdeTSUmUU4SjnU"5(deT$) 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>TRS5nURTRS55(deg![a gf=f)Nutf-8T)rUnicodeDecodeError startswith)textrrs ra sanity_check#utf8_truncate..sanity_checksM ==)D v}}W56666 "  s< A A )rrr!rtmaxminr,)rindexrr*rs` @rarrcs2 fe $ $x88 f+C qyAu{# |  eai C + 6%= )D 0D 8    +||FU^F  >>> MrVs aA:#!asciic:[RU5[:H$)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 rais_ascii_codecr4s  % %e ,0A AArVcX:XagU(aU(dg[U5R[U5R:H$)z3Check if two codec names are aliases for same codecTF) _lookup_codecnamers rar:r:s3 } U   # #}U';'@'@ @@rVr$€cp^[U[5(a[O[m[ U4SjU55$)z# UH oT:v M g7frer)rrrs rar is_ascii_safe..s%f1ufs)rr_B80_U80all)rrs @rar;r;s'65))tA %f% %%rVcU(de[U[5(a9U(a0[X15(d URU5R U5$U$[U[ 5(aUR U5$[ X5e)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 rar<r<sk4 O8&%  =#K#K==188B BM FG $ $}}X&&!&00rVcU(de[U[5(aU$[U[5(aURU5$[ X5e)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 rr@rs rar=r=sD$ O8&'"" FE " "}}X&&!&00rVc[U[5(aURU5$[U[5(aU$[ X5ere)rrrr+r rCs rar>r>s; fe $ $==* *  ( (M%f4 4rVc[U[5(aU$[U[5(aURU5$[ X5ere)rrr+rr rCs rar>r>s; fe $ $M  ( (==* *%f4 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[XSS9$)z'deprecated, use to_native_str() insteadhash)r)r>)rr@s ra to_hash_strrJ$s  88rVz true t yes y on 1 enable enabledz#false f no n off 0 disable disablednonec0US;de[U[5(aSUR5R5nU[;agU[ ;agU[ ;aU$[SU<SU<35e[U[5(aU$UcU$[U5$)zP helper to convert value to boolean. recognizes strings such as "true", "false" )TFNTFz unrecognized z value: ) rr/lowerr _true_set _false_set _none_setrbool)rrKrcleans raas_boolrS-s & && &%/00 ##% I  J  I KuEFF E4   E{rVc[(d[U[5(dgURS5 g![a gf=f)zs UT helper -- test if value is safe to pass to crypt.crypt(); under PY3, can't pass non-UTF8 bytes to crypt.crypt. Tr&F)crypt_accepts_bytesrrrr'rs rais_safe_crypt_inputrVGs? *UE":": W s5 AA)cryptT)rKr)rXr"r") nullcontextz*:!xxc[(ab[U[5(aURS5n[U;a [ S5e[U[5(aURS5nO[U[ 5(a0UnURS5nURS5U:XdS5e[U;a [ S5e[U[ 5(aURS5n[ [X5nSSS5 [W[ 5(aURS5nU(a US[;agU$![a gf=f!,(df  N[=f![a gf=f)Nr&null character in secretr/z"utf-8 spec says this can't happen!r)rUrr+rrrrrr'_NULL_safe_crypt_lock_cryptOSError_invalid_prefixes)secretrIorigrs rarArAsJ""fg..#]]73FV#$%?@@dG,,;;w/D fe,,!D$!'w!7 "==1T9E DE9F?$%?@@dE**;;w/D %#F1F&&%((w/VAY*;;M3.$#$&%   sBE/E'5 EE' EE E$ E'$E'' E43E4cl[U[5(aURS5n[U;a [ S5e[U[5(aURS5n[  [ X5nSSS5 W(dgURS5nUS[;agU$!,(df  N7=f)Nr&r]r/r) rr+rr^rr_r`rrb)rcrIrs rarArAs&'**w/ !;<<$(({{7+!-"]]7+Fay--M"!s ( B%% B3cgrerrcrIs rarArA]srVaWrapper 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. c[U[5(dS[U5-5eU(dS5e[X5U:H$)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.rrArgs rar@r@sH dN + +;-T :; + )))4 f #t ++rVc[R"SU5nU(a0[SURS5R S555$g)zhelper to parse version stringz(\d+(?:\.\d+)+)c38# UHn[U5v M g7fre)r)rrs rar parse_version..sA+@4SYY+@sr.N)researchrgroupr)rms ra parse_versionrqs= $f-AA1771:+;+;C+@AAA rVrc HSSKJn [US5(a"[US5(aUR5n[ S5U[[S5(a[R"5OS[[55[R"5[5[(a%[R"S 5RS 5OS4-n[!U"UR#S 55R%5S 5$![a UR S5nNf=f) z.generate prng seed value from system resourcesr)sha512getstate getrandbitsiz%s %s %s %.15f %.15f %sgetpidN rr&r)hashlibrshasattrrtr^rur)osrvidobjecttimerB has_urandomurandomrrr hexdigest)rrsr)s ragenseedrsuj!!ge]&C&C /NN$E & ' r8,, $ 68   -8K 2i(Q#+  D( vdkk'*+557 <<1# /%%g.E /sDD! D!cN^^T(d[$UU4Sjn[U"55$)z]return byte-string containing *count* number of randomly generated bytes, using specified rngc3z># TRTS-5nSnUT:aUS-v US-nUS- nUT:aMgg7f)Nr"rr)ru)rrr rCs rahelpergetrandbytes..helperMsIq) %i$,  aKE FA%is4;;)_BEMPTYr$)rCr rs`` rarDrDBs!  FH %%rVc^^^^TS:a [S5e[T5mTS:Xa [S5eTS:XaTT-$UUUU4Sjn[T[5(a[ U"55$[ U"55$)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 emptyrc3># TRSTT-5nSnUT:aTUT-v UT-nUS- nUT:aMgg7f)Nrr) randrange)rrcharsetr lettersrCs rargetrandstr..helperfsQ a%0 %i%'/* * g E FA%is8??)rrtrr+r*r%)rCrr rrs``` @rarErEWsx  qy-..'lG!|566!|'7##FH%%vx((rV42346789ABCDEFGHJKMNPQRTUVWXYZabcdefghjkmnpqrstuvwxyzz2.0z/passlib.pwd.genword() / passlib.pwd.genphrase())rFrG replacement c"[[X5$)aGgenerate 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)rrs rarFrFvs, c7 ))rV)r7 setting_kwds context_kwdsverifyrIidentifyc6^[U4Sj[55$)z4check if object follows the :ref:`password-hash-api`c3<># UHn[TU5v M g7freryrr7objs rar#is_crypt_handler..=ndwsD!!nr)r>_handler_attrsrs`rarGrG =n= ==rV) needs_update genconfiggenhashrencryptrc6^[U4Sj[55$)zOcheck if object appears to be a :class:`~passlib.context.CryptContext` instancec3<># UHn[TU5v M g7frerrs rar#is_crypt_context..rr)r>_context_attrsrs`rarHrHrrVcLSUR;=(a [USS5SL$)z_check if handler provides the optional :ref:`rounds information ` attributesrounds min_roundsNrgetattrhandlers rarIrIs+ ,, , = G\4 0 <>rVcLSUR;=(a [USS5SL$)z[check if handler provides the optional :ref:`salt information ` attributessalt min_salt_sizeNrrs rarJrJs- g** * @ G_d 34 ?ArV)NNFNNF),rre)r&rN)r&r)r/)Nboolean)rpasslib.utils.compatrbinasciirrr_BinAsciiErrorbase64rrcollections.abcr r ImportError collectionscodecsr r6 functoolsr rrlogging getLoggerrlogmathrzsysrandomrmrrr}r 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__rmaxsizemaxintr3r4r5rUrrrenvironrMAX_PASSWORD_SIZEr|r[ Parameter VAR_KEYWORDrsetVAR_POSITIONALrrrrr6 str_consteqhmacrrr7r9rr r r r8rrrrr rr2rr1r4r:r<r=r;r<r=r>rJrrNrOrPrSrVrWr`r?r^pypy_version_infoLockr_crypt_needs_lockrYrbrUrrAr@ default_timertimerrBrqrr~r^r SystemRandomrCRandomrDrE _52charsetrFrrGrrHrIrJrrVrars:(DD'%(( +$g''1  @     ?MMMMM ' \ txxs  A>D E ),  B% C& 'BCKtL &F&4$$00L g&7&7&F&FGHL == @E9>R(n3>8|  . :}@N$,,,,&: GH GHM".  6AL('..w7BAy& #1J1455  *u5969 288: ; 6<<> ? V  4 s%I ETi3+@+@MIM%>>+  5&= % #  7D !+ ^#    < ,  ,JJqMK=B    C -- "C &*):D u!RTz*T*2  >   >> AK%%$$$%& @ %?"@Ij   D ("'   _ FI zKs} O(.PPP!P>? P.1Q(O>=O> PPPP!P+*P+.P;8P;>QQQ#"Q#