+
    THim                       R t ^ RIHt ^ RIHt ^ RIHt ^ RIH	t
 ^ RIHtHt ^ RIHtHt ^ RIHt ^ RIHtHtHt ^ R	IHt ]'       d   ^ R
IHt . R,OtRtRtRtRt]R,           tRt Rt!Rt"]#! ]$! R4      4      t%Rt&Rt'Rt(])! ]! ]%4      4      t*R-R R llt+R t,R t-Rt.Rt/Rt0R  t1R! t2R" t]+! R#R$R%R&/4      t3](^,          t4R' t ! R( R4      t5 ! R) R]54      t6]6! ]4      t7]6! ]R*R+7      t8]6! ]R*R+7      t9R# ).zC
passlib.utils.binary - binary data encoding/decoding/manipulation
)annotations)	b32decode)	b32encode)Error)
a2b_base64
b2a_base64)TYPE_CHECKINGAnyStr)exc)bascii_to_striter_byte_charsunicode_or_bytes)memoized_property)MappingBase64EngineLazyBase64Enginez@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/z@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./z@./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzz@./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789=0123456789abcdefABCDEF0123456789ABCDEF0123456789abcdef              =Nc                    V ^8  d   QhRRRR/# )   mappingz#Mapping[int | AnyStr, int | AnyStr]returnbytes )formats   "6/usr/lib/python3/dist-packages/passlib/utils/binary.py__annotate__r"   j   s     $  $ 0$  $ r   c                B   Vf   \         R,          pM>\        V\        4      '       g   Q h\        V4      ^8X  g   Q h\	        \        V4      4      pV P                  4        F  w  r4\        V\        4      '       d   \        V4      p\        V\        4      '       g   Q h^ Tu;8:  d	   R8  g   Q h Q h\        V\        4      '       d   VP                  R4      p\        V\        4      '       g   Q h\        V4      ^8X  g   Q hWBV&   K  	  \        P                  V4      # )a  
return a 256-byte string for translating bytes using specified mapping.
bytes not specified by mapping will be left alone.

:param mapping:
    dict mapping input byte (str or int) -> output byte (str or int).

:param source:
    optional existing byte translation string to use as base.
    (must be 255-length byte string).  defaults to identity mapping.

:returns:
    255-length byte string for passing to bytes().translate.
:NNNr   ascii)_TRANSLATE_SOURCE
isinstancer   lenlistr   itemsr   ordintstrencodeB_EMPTYjoin)r   sourcetargetkvs   &&   r!   compile_byte_translationr4   j   s    $ ~"1%&%((((6{c!!!of-. a)**AA!S!!!!A||||a!A!U####1v{{q	   <<r   c                >    \        V 4      P                  \        4      # )zf
encode using shortened base64 format which omits padding & whitespace.
uses default ``+/`` altchars.
)r   rstrip_BASE64_STRIPdatas   &r!   b64s_encoder:      s    
 d""=11r   c                |   \        V \        4      '       d    V P                  R4      p \        V 4      ^,          pV^ 8X  d   M5V^8X  d   V \        ,          p M V^8X  d   V \        ,          p M\	        R4      h \        V 4      #   \         d    \	        R4      Rhi ; i  \         d   p\        T4      RhRp?ii ; i)ze
decode from shortened base64 format which omits padding & whitespace.
uses default ``+/`` altchars.
r$   4string argument should contain only ASCII charactersNzinvalid base64 input)r&   r,   r-   UnicodeEncodeError
ValueErrorr'   _BASE64_PAD2_BASE64_PAD1r   _BinAsciiError	TypeError)r9   offerrs   &  r!   b64s_decoderE      s    
 $	;;w'D
 d)a-C
ax		/00'$ " 	F	  'n$&'s#   B 9
B BB;*B66B;s   =
s   ==c                8    \        V 4      P                  RR4      # )z
encode using shortened base64 format which omits padding & whitespace.
uses custom ``./`` altchars.

it is primarily used by Passlib's custom pbkdf2 hashes.
   +   .)r:   replacer8   s   &r!   ab64_encoderJ      s     t$$T400r   c                    \        V \        4      '       d    V P                  R4      p \        V P                  RR4      4      #   \         d    \	        R4      Rhi ; i)z
decode from shortened base64 format which omits padding & whitespace.
uses custom ``./`` altchars, but supports decoding normal ``+/`` altchars as well.

it is primarily used by Passlib's custom pbkdf2 hashes.
r$   r<   NrH   rG   )r&   r,   r-   r=   r>   rE   rI   r8   s   &r!   ab64_decoderL      s`     $	;;w'D
 t||D$/00	 " 	F	s   A Ac                P    \        \        V 4      P                  \        4      4      # )z\
wrapper around :func:`base64.b32encode` which strips padding,
and returns a native string.
)r   
_b32encoder6   B_EQUAL)r0   s   &r!   r   r      s     F+227;<<r   8B0Oc                    \        V \        4      '       d   V P                  R4      p V P                  \        4      p \        V 4      ^,          pV'       d   V \        RV)  ,          p \        V R4      # )zt
wrapper around :func:`base64.b32decode`
which handles common mistyped chars.
padding optional, ignored if present.
r$   NT)r&   r,   r-   	translate_b32_translater'   _b32_decode_pad
_b32decode)r0   	remainders   & r!   r   r      sd     &#w'n-F Fc!I/+I:.. fd##r   c                      ] tR tRtRtRtRtRtRtRt	Rt
R R lt]R 4       tR tR tR tR	 tR
 tR tR t]R 4       t]R 4       tR tR tR tR tR tR tR tR tR t R t!R t"R t#R t$R t%R t&R t'Rt(R# )!r   r   a  Provides routines for encoding/decoding base64 data using
arbitrary character mappings, selectable endianness, etc.

:arg charmap:
    A string of 64 unique characters,
    which will be used to encode successive 6-bit chunks of data.
    A character's position within the string should correspond
    to its 6-bit value.

:param big:
    Whether the encoding should be big-endian (default False).

.. note::
    This class does not currently handle base64's padding characters
    in any way what so ever.

Raw Bytes <-> Encoded Bytes
===========================
The following methods convert between raw bytes,
and strings encoded using the engine's specific base64 variant:

.. automethod:: encode_bytes
.. automethod:: decode_bytes
.. automethod:: encode_transposed_bytes
.. automethod:: decode_transposed_bytes

..
    .. automethod:: check_repair_unused
    .. automethod:: repair_unused

Integers <-> Encoded Bytes
==========================
The following methods allow encoding and decoding
unsigned integers to and from the engine's specific base64 variant.
Endianess is determined by the engine's ``big`` constructor keyword.

.. automethod:: encode_int6
.. automethod:: decode_int6

.. automethod:: encode_int12
.. automethod:: decode_int12

.. automethod:: encode_int24
.. automethod:: decode_int24

.. automethod:: encode_int64
.. automethod:: decode_int64

Informational Attributes
========================
.. attribute:: charmap

    unicode string containing list of characters used in encoding;
    position in string matches 6bit value of character.

.. attribute:: bytemap

    bytes version of :attr:`charmap`

.. attribute:: big

    boolean flag indicating this using big-endian encoding.
Nc                	\   \        V\        4      '       d   VP                  R 4      pM-\        V\        4      '       g   \        P
                  ! VR4      h\        V4      ^@8w  d   \        R4      h\        \        V4      4      ^@8w  d   \        R4      hWn	        VP                  V n        \        R \        V4       4       4      pVP                  V n        W n        V'       d%   V P                   V n        V P$                  V n        R# V P(                  V n        V P*                  V n        R# )latin-1charmapz'charmap must be 64 characters in lengthz-charmap must not contain duplicate charactersc              3  ,   "   T F
  w  rW!3x  K  	  R # 5iNr   ).0idxvalues   &  r!   	<genexpr>(Base64Engine.__init__.<locals>.<genexpr>Z  s     H5Gzsul5Gs   N)r&   r,   r-   r   r
   ExpectedStringErrorr'   r>   setbytemap__getitem__	_encode64dict	enumerate	_decode64big_encode_bytes_big_encode_bytes_decode_bytes_big_decode_bytes_encode_bytes_little_decode_bytes_little)selfr]   rm   lookups   &&& r!   __init__Base64Engine.__init__N  s    gs##nnY/GGU++))'9==w<2FGGs7|"LMM ,,HYw5GHH++ !%!7!7D!%!7!7D!%!:!:D!%!:!:Dr   c                8    V P                   P                  R4      # )zcharmap as unicoder\   )rg   decode)rt   s   &r!   r]   Base64Engine.charmapp  s     ||""9--r   c                   \        V\        4      '       g   \        R\        V4       24      h\	        \        V4      ^4      w  r#\        V4      P                  pV P                  WBV4      p\        \        V P                  V4      4      # )zsencode bytes to base64 string.

:arg source: byte string to encode.
:returns: byte string containing encoded data.
source must be bytes, not )r&   r   rB   typedivmodr'   iter__next__ro   mapri   )rt   r0   chunkstail
next_valuegens   &&    r!   encode_bytesBase64Engine.encode_bytesu  sq     &%((8fGHHc&k1-&\**
  T:S-..r   c              #    "   ^ pWB8  dw   V! 4       pV! 4       pV! 4       pV^?,          x  V^,          ^,          V^,	          ,          x  V^,          ^,          V^,	          ,          x  V^,	          x  V^,          pK|  V'       do   V! 4       pV^8X  d   V^?,          x  V^,	          x  R# V^8X  g   Q hV! 4       pV^?,          x  V^,          ^,          V^,	          ,          x  V^,	          x  R# R# 5i)z>helper used by encode_bytes() to handle little-endian encodingNr   rt   r   r   r   ra   v1v2v3s   &&&&    r!   rr   !Base64Engine._encode_bytes_little  s      lBBBt)OI!#a00I!#a00'M1HCBqy4iAgqy y\4iT	a'B!G44Ag s   BC9	A0C9c              #    "   ^ pWB8  dw   V! 4       pV! 4       pV! 4       pV^,	          x  V^,          ^,          V^,	          ,          x  V^,          ^,          V^,	          ,          x  V^?,          x  V^,          pK|  V'       d}   V! 4       pV^8X  d    V^,	          x  V^,          ^,          x  R# V^8X  g   Q hV! 4       pV^,	          x  V^,          ^,          V^,	          ,          x  V^,          ^,          x  R# R# 5i)z;helper used by encode_bytes() to handle big-endian encodingNr   r   s   &&&&    r!   rn   Base64Engine._encode_bytes_big  s      lBBB'MI!#a00I!#a00t)O1HCBqyAgDyQ&&qy y\AgT	a'B!G44T	a'( s   BD	A>Dc                   \        V\        4      '       g   \        R\        V4       24      h\	        \        V4      ^4      w  r#V^8X  d   \        R4      h\        V P                  V4      P                  p \        V P                  WBV4      4      #   \         d&   p\        RTP                  ^ ,          : 24      hRp?ii ; i)zudecode bytes from base64 string.

:arg source: byte string to decode.
:returns: byte string containing decoded data.
r|   z(input string length cannot be == 1 mod 4zinvalid character: N)r&   r   rB   r}   r~   r'   r>   r   rl   r   rq   KeyErrorargs)rt   r0   r   r   r   rD   s   &&    r!   decode_bytesBase64Engine.decode_bytes  s     &%((8fGHH
 c&k1-19GHH099
	D++JEFF 	D2388A;/BCC	Ds   8B C B>>Cc              #    "   ^ pWB8  dy   V! 4       pV! 4       pV! 4       pV! 4       pWV^,          ^,          ,          x  V^,	          V^,          ^,          ,          x  V^,	          V^,          ,          x  V^,          pK~  V'       dY   V! 4       pV! 4       pWV^,          ^,          ,          x  V^8X  d*   V! 4       pV^,	          V^,          ^,          ,          x  R# R# R# 5i)z>helper used by decode_bytes() to handle little-endian encodingNr   	rt   r   r   r   ra   r   r   r   v4s	   &&&&     r!   rs   !Base64Engine._decode_bytes_little  s      lBBBBca((7SQ//7rQw''1HCBBca((qy\QwBH?33  s   BC%AC%c              #    "   ^ pWB8  dz   V! 4       pV! 4       pV! 4       pV! 4       pV^,          V^,	          ,          x  V^,          ^,          V^,	          ,          x  V^,          ^,          V,          x  V^,          pK  V'       dZ   V! 4       pV! 4       pV^,          V^,	          ,          x  V^8X  d*   V! 4       pV^,          ^,          V^,	          ,          x  R# R# R# 5i)z;helper used by decode_bytes() to handle big-endian encodingNr   r   s	   &&&&     r!   rp   Base64Engine._decode_bytes_big  s      lBBBB7rQw''H?rQw//H?b((1HCBB7rQw''qy\SQ2733  s   B	C'AC'c                   a \        V3R l\        V P                  4       4       4      pVP                  V3R l\        V P                  4       4       4       \        V4      # )z2helper to generate set of valid last chars & bytesc              3  N   <"   T F  w  rVS,          '       d   K  Vx  K  	  R # 5ir_   r   r`   icbitss   &  r!   rc   -Base64Engine.__make_padset.<locals>.<genexpr>5  s     I!8D11!8   %
%c              3  N   <"   T F  w  rVS,          '       d   K  Vx  K  	  R # 5ir_   r   r   s   &  r!   rc   r   6  s     J"9$!TAA"9r   )rf   rk   rg   updater]   	frozenset)rt   r   psets   &f r!   __make_padsetBase64Engine.__make_padset3  sA    I4<<!8IIJ)DLL"9JJr   c                V    V P                   '       d   ^M^<pV( V P                  V4      3# )zDmask to clear padding bits, and valid last bytes (for strings 2 % 4)rm   _Base64Engine__make_padsetrt   r   s   & r!   	_padinfo2Base64Engine._padinfo29  s+     XXXrGud((...r   c                V    V P                   '       d   ^M^0pV( V P                  V4      3# )zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)r   r   s   & r!   	_padinfo3Base64Engine._padinfo3@  s+     HHHq6ud((...r   c                
   \        V4      ^,          pV^8X  d   V P                  w  r4M-V^8X  d   V P                  w  r4MV'       g   RV3# \        R4      hVR,          pWT9   d   RV3# \	        V\
        4      '       d9   V P                  pWfP                  V4      V,          ,          pWT9   g   Q R4       hM@V P                  V P                  V4      V,          4      pWT9   g   Q R4       h\        V.4      pRVRR V,           3# )zhelper to detect & clear invalid unused bits in last character.

:arg source:
    encoded data (as ascii bytes or unicode).

:returns:
    `(True, result)` if the string was repaired,
    `(False, source)` if the string was ok as-is.
Fzsource length must != 1 mod 4z%failed to generate valid padding charTN)r'   r   r   r>   r&   r,   r]   indexri   rl   r   )rt   r0   r   maskpadsetlastcms   &&     r!   check_repair_unused Base64Engine.check_repair_unusedG  s     6{Q19>>LD&QY>>LD&&= <== bz>&=  fc""Bhhtnt+,D>J#JJ> >>$.."6"=>D>J#JJ>$=DVCR[4'''r   c                	2    V P                  V4      ^,          # )   )r   rt   r0   s   &&r!   repair_unusedBase64Engine.repair_unusedo  s    ''/22r   c                   a \        S\        4      '       g   \        R\        S4       24      h\        V3R lV 4       4      pV P	                  V4      # )z>encode byte string, first transposing source using offset listr|   c              3  6   <"   T F  pSV,          x  K  	  R # 5ir_   r   )r`   rC   r0   s   & r!   rc   7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>  s     37CF3KK7s   )r&   r   rB   r}   r   )rt   r0   offsetstmps   &f& r!   encode_transposed_bytes$Base64Engine.encode_transposed_bytes~  sH    &%((8fGHH3733  %%r   c                    V P                  V4      pR.\        V4      ,          p\        W#4       F	  w  rVWdV&   K  	  \        V4      # )zGdecode byte string, then reverse transposition described by offset listN)r   r'   zipr   )rt   r0   r   r   bufrC   chars   &&&    r!   decode_transposed_bytes$Base64Engine.decode_transposed_bytes  sF    
 'fs7|#W*ICH +Szr   c                   \        V\        4      '       g   \        R\        V4       24      hV P                  pV) ^,          pW$,           ^,          p\        V4      V8w  d   \        RV3,          4      hV P                  p^ p V'       d   TM
\        V4       F  pV^,          V! V4      ,           pK  	  T'       d*   T'       d   Yt,          pT# T^T,          ^,
          ,          pT#   \         d    \        RX: 24      hi ; i)ac  decode base64 string -> integer

:arg source: base64 string to decode.
:arg bits: number of bits in resulting integer.

:raises ValueError:
    * if the string contains invalid base64 characters.
    * if the string is not long enough - it must be at least
      ``int(ceil(bits/6))`` in length.

:returns:
    a integer in the range ``0 <= n < 2**bits``
r|   zsource must be %d charszinvalid character in string: )
r&   r   rB   r}   rm   r'   r>   rl   reversedr   )	rt   r0   r   rm   padcharsry   outr   s	   &&&      r!   _decode_intBase64Engine._decode_int  s     &%((8fGHHhheaiq v;%6%ABB	D"V(88ax6!9, 9  
 T	Q&
  	D<QEBCC	Ds   C* *C* *Dc                    \        V\        4      '       g   \        R\        V4       24      h\	        V4      ^8w  d   \        R4      hV^ ,          p V P                  V4      #   \         d    \        R4      hi ; i)z(decode single character -> 6 bit integerr|   zsource must be exactly 1 byteinvalid character)r&   r   rB   r}   r'   r>   rl   r   r   s   &&r!   decode_int6Base64Engine.decode_int6  sv    &%((8fGHHv;!<==	2>>&)) 	2011	2s   A$ $A;c                   \        V\        4      '       g   \        R\        V4       24      h\	        V4      ^8w  d   \        R4      hV P                  p V P                  '       d+   V! V^,          4      V! V^ ,          4      ^,          ,           # V! V^ ,          4      V! V^,          4      ^,          ,           #   \         d    \        R4      hi ; i)z'decodes 2 char string -> 12-bit integerr|   zsource must be exactly 2 bytesr   	r&   r   rB   r}   r'   r>   rl   rm   r   rt   r0   ry   s   && r!   decode_int12Base64Engine.decode_int12  s    &%((8fGHHv;!=>>	2xxxfQi(F6!9,=,BCC&)$vay(9Q(>?? 	2011	2s   B< ()B< )B< <Cc                   \        V\        4      '       g   \        R\        V4       24      h\	        V4      ^8w  d   \        R4      hV P                  p V P                  '       da   V! V^,          4      V! V^,          4      ^,          ,           V! V^,          4      ^,          ,           V! V^ ,          4      ^,          ,           # V! V^ ,          4      V! V^,          4      ^,          ,           V! V^,          4      ^,          ,           V! V^,          4      ^,          ,           #   \         d    \        R4      hi ; i)z'decodes 4 char string -> 24-bit integerr|   zsource must be exactly 4 bytesr   r   r   s   && r!   decode_int24Base64Engine.decode_int24  s   &%((8fGHHv;!=>>	2xxx6!9%fQi(A-/fQi(B.0 fQi(B.0 vay!&)$)+&)$*, &)$*,  	2011	2s   D( (AD( AD( (D?c                &    V P                  V^4      # )&decode 5 char string -> 30 bit integerr   r   s   &&r!   decode_int30Base64Engine.decode_int30  s    ++r   c                &    V P                  V^@4      # )zdecode 11 char base64 string -> 64-bit integer

this format is used primarily by des-crypt & variants to encode
the DES output value used as a checksum.
r   r   s   &&r!   decode_int64Base64Engine.decode_int64  s     ++r   c                  a S^ 8  g   Q R4       hV) ^,          pW#,          pV P                   '       d   \        V^,
          RR4      pSV,          oM\        ^ V^4      p\        \        V P                  V3R lV 4       4      4      # )zencode integer into base64 format

:arg value: non-negative integer to encode
:arg bits: number of bits to encode

:returns:
    a string of length ``int(ceil(bits/6.0))``.
zcaller did not sanitize inputc              3  D   <"   T F  pSV,	          ^?,          x  K  	  R# 5i)?   Nr   )r`   rC   rb   s   & r!   rc   +Base64Engine._encode_int.<locals>.<genexpr>
  s     )O3C5C<4*?*?3s    i)rm   ranger   r   ri   )rt   rb   r   r   itrs   &f&  r!   _encode_intBase64Engine._encode_int  sw     z:::zeai888q"b)CcME4#CS)O3)OPQQr   c                ^    V^ 8  g   V^?8  d   \        R4      hV P                  W^,            # )z0encodes 6-bit integer -> single hash64 charactervalue out of range)r>   rg   rt   rb   s   &&r!   encode_int6Base64Engine.encode_int6  s.    19
122||EAI..r   c                    V^ 8  g   VR8  d   \        R4      hV^?,          V^,	          ^?,          .pV P                  '       d   VP                  4        \        \	        V P
                  V4      4      # )z'encodes 12-bit integer -> 2 char stringi  r   r>   rm   reverser   r   ri   rt   rb   raws   && r!   encode_int12Base64Engine.encode_int12  sZ    19122t|eqjD01888KKMS-..r   c                $   V^ 8  g   VR8  d   \        R4      hV^?,          V^,	          ^?,          V^,	          ^?,          V^,	          ^?,          .pV P                  '       d   VP                  4        \        \	        V P
                  V4      4      # )z'encodes 24-bit integer -> 4 char stringi r   r   r   s   && r!   encode_int24Base64Engine.encode_int24  sx    19(122DLaZ4b[D b[D 	
 888KKMS-..r   c                X    V^ 8  g   VR8  d   \        R4      hV P                  V^4      # )r   i?r   r>   r   r   s   &&r!   encode_int30Base64Engine.encode_int30-  s/    19
*122r**r   c                X    V^ 8  g   VR8  d   \        R4      hV P                  V^@4      # )zencode 64-bit integer -> 11 char hash64 string

this format is used primarily by des-crypt & variants to encode
the DES output value used as a checksum.
l    r   r   r   s   &&r!   encode_int64Base64Engine.encode_int643  s2     19 22122r**r   )rl   rq   ri   ro   rm   rg   )F))__name__
__module____qualname____firstlineno____doc__rg   rm   ri   rl   ro   rq   rv   propertyr]   r   rr   rn   r   rs   rp   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  __static_attributes__r   r   r!   r   r      s    >B G
C II MM;D . ./"%N%)ND,!4F!4L / / / /&(P3&	"P2220,,R2///++r   c                  <   a  ] tR tRtRtRtR tV 3R ltR tRt	V ;t
# )r   i>  z<Base64Engine which delays initialization until it's accessedNc                	    W3V n         R # r_   )
_lazy_opts)rt   r   kwdss   &*,r!   rv   LazyBase64Engine.__init__C  s    ,r   c                	^   < V P                   w  r\        SV `  ! V/ VB  V = \        V n        R # r_   )r  superrv   r   	__class__)rt   r   r  r  s   &  r!   
_lazy_initLazyBase64Engine._lazy_initF  s,    __
$'$'O%r   c                	z    VP                  R 4      '       g   V P                  4        \        P                  W4      # )_)
startswithr  object__getattribute__)rt   attrs   &&r!   r  !LazyBase64Engine.__getattribute__L  s,    s##OO&&t22r   )r  r  )r  r  r  r	  r
  r  rv   r  r  r  __classcell__)r  s   @r!   r   r   >  s    FJ'&3 3r   T)rm   )BASE64_CHARSPADDED_BASE64_CHARS
AB64_CHARSHASH64_CHARSBCRYPT_CHARS	HEX_CHARSLOWER_HEX_CHARSUPPER_HEX_CHARSALL_BYTE_VALUESr4   rJ   rL   r:   rE   r   r   r   r   h64h64bigbcrypt64r_   ):r
  
__future__r   base64r   rX   r   rN   binasciir   rA   r   r   typingr   r	   passlibr
   passlib.utils.compatr   r   r   passlib.utils.decorr   collections.abcr   __all__r  r!  r"  r#  r   r$  r&  r%  r   r   r'  r.   B_NULLrO   r(   r%   r4   r:   rE   r7   r@   r?   rJ   rL   rV   rW   r   r   r(  r)  r*  r   r   r!   <module>r5     sK   # - + (  
 2'F R P
 R R #S(  %	 % % c
# 	
 9: $ N2'8 11$= *3S#*>? A+$*{+ {+|3| 3( |$	,D	1Ld3r   