ó
    E>Ùj-W  ã                   óØ  • S r SSKrSSKrSSKr/ SQr\\4rS rS:S jr	S;S jr
S rS	 r\R                  S
S5      r\R                  SS
5      rS rS rSrSrSrSrSr0 r0 rS rS<S jrS r\R9                  SS9\l         S<S jr\R9                  S\S9\l         S r\R9                  SS9\l         S=S jr\R9                  SSS9\l         S r S=S jr!Sq"Sq#S r$S!r%S>S" jr&SSSSS#.S$ jr'SSS%S&.S' jr(S(r)Sq*Sq+Sq,S=S) jr-S* r.S+r/S,r0\R                  \/\0-   \)S-\1" \05      -  -   5      r2\R                  \)\/5      r3S. r4S/ r5S0r6\6S1-  S2-  r7S3 r8S4 r9S5 r:S6 r;S7 r<S8 r=\>S9:X  a  \=" 5         gg)?zDBase16, Base32, Base64 (RFC 4648), Base85 and Ascii85 data encodingsé    N)ÚencodeÚdecodeÚencodebytesÚdecodebytesÚ	b64encodeÚ	b64decodeÚ	b32encodeÚ	b32decodeÚb32hexencodeÚb32hexdecodeÚ	b16encodeÚ	b16decodeÚ	b85encodeÚ	b85decodeÚ	a85encodeÚ	a85decodeÚ	z85encodeÚ	z85decodeÚstandard_b64encodeÚstandard_b64decodeÚurlsafe_b64encodeÚurlsafe_b64decodec                 óF  • [        U [        5      (       a   U R                  S5      $ [        U [
        5      (       a  U $  [        U 5      R                  5       $ ! [         a    [	        S5      ef = f! [         a$    [        SU R                  R                  -  5      S ef = f)NÚasciiz4string argument should contain only ASCII charactersz>argument should be a bytes-like object or ASCII string, not %r)Ú
isinstanceÚstrr   ÚUnicodeEncodeErrorÚ
ValueErrorÚbytes_typesÚ
memoryviewÚtobytesÚ	TypeErrorÚ	__class__Ú__name__©Úss    Ú#/usr/local/lib/python3.13/base64.pyÚ_bytes_from_decode_datar(   "   s¬   € Ü�!”S×Ñð	UØ—8‘8˜GÓ$Ð$ô �!”[×!Ñ!ØˆðKÜ˜!‹}×$Ñ$Ó&Ð&øô "ó 	UÜÐSÓTÐTð	Uûô ó KÜð )Ø+,¯;©;×+?Ñ+?ñ@ó AØFJð	KðKús   —A Á A2 ÁA/Á2.B c                 ó¾   • [         R                  " U SS9nUbD  [        U5      S:X  d   [        U5      5       eUR	                  [
        R                  SU5      5      $ U$ )a  Encode the bytes-like object s using Base64 and return a bytes object.

Optional altchars should be a byte string of length 2 which specifies an
alternative alphabet for the '+' and '/' characters.  This allows an
application to e.g. generate url or filesystem safe Base64 strings.
F)Únewlineé   ó   +/)ÚbinasciiÚ
b2a_base64ÚlenÚreprÚ	translateÚbytesÚ	maketrans)r&   ÚaltcharsÚencodeds      r'   r   r   3   sX   € ô ×!Ò! !¨UÑ3€GØÑÜ�8‹} Ó!Ð1¤4¨£>Ó1Ð!Ø× Ñ ¤§¡°¸Ó!AÓBÐBØ€Nó    Fc                 óä   • [        U 5      n UbO  [        U5      n[        U5      S:X  d   [        U5      5       eU R                  [        R                  US5      5      n [        R                  " XS9$ )aÇ  Decode the Base64 encoded bytes-like object or ASCII string s.

Optional altchars must be a bytes-like object or ASCII string of length 2
which specifies the alternative alphabet used instead of the '+' and '/'
characters.

The result is returned as a bytes object.  A binascii.Error is raised if
s is incorrectly padded.

If validate is False (the default), characters that are neither in the
normal base-64 alphabet nor the alternative alphabet are discarded prior
to the padding check.  If validate is True, these non-alphabet characters
in the input result in a binascii.Error.
For more information about the strict base64 check, see:

https://docs.python.org/3.11/library/binascii.html#binascii.a2b_base64
r+   r,   )Ústrict_mode)r(   r/   r0   r1   r2   r3   r-   Ú
a2b_base64)r&   r4   Úvalidates      r'   r   r   A   sc   € ô$ 	  Ó"€AØÑÜ*¨8Ó4ˆÜ�8‹} Ó!Ð1¤4¨£>Ó1Ð!Ø�K‰KœŸ™¨°%Ó8Ó9ˆÜ×Ò˜qÑ7Ð7r6   c                 ó   • [        U 5      $ )zjEncode bytes-like object s using the standard Base64 alphabet.

The result is returned as a bytes object.
)r   r%   s    r'   r   r   [   s   € ô
 �Q‹<Ðr6   c                 ó   • [        U 5      $ )a=  Decode bytes encoded with the standard Base64 alphabet.

Argument s is a bytes-like object or ASCII string to decode.  The result
is returned as a bytes object.  A binascii.Error is raised if the input
is incorrectly padded.  Characters that are not in the standard alphabet
are discarded prior to the padding check.
)r   r%   s    r'   r   r   b   s   € ô �Q‹<Ðr6   r,   s   -_c                 ó>   • [        U 5      R                  [        5      $ )zØEncode bytes using the URL- and filesystem-safe Base64 alphabet.

Argument s is a bytes-like object to encode.  The result is returned as a
bytes object.  The alphabet uses '-' instead of '+' and '_' instead of
'/'.
)r   r1   Ú_urlsafe_encode_translationr%   s    r'   r   r   p   s   € ô �Q‹<×!Ñ!Ô"=Ó>Ð>r6   c                 óX   • [        U 5      n U R                  [        5      n [        U 5      $ )a²  Decode bytes using the URL- and filesystem-safe Base64 alphabet.

Argument s is a bytes-like object or ASCII string to decode.  The result
is returned as a bytes object.  A binascii.Error is raised if the input
is incorrectly padded.  Characters that are not in the URL-safe base-64
alphabet, and are not a plus '+' or slash '/', are discarded prior to the
padding check.

The alphabet uses '-' instead of '+' and '_' instead of '/'.
)r(   r1   Ú_urlsafe_decode_translationr   r%   s    r'   r   r   y   s'   € ô 	  Ó"€AØ	�‰Ô/Ó0€AÜ�Q‹<Ðr6   zK
Encode the bytes-like objects using {encoding} and return a bytes object.
aƒ  
Decode the {encoding} encoded bytes-like object or ASCII string s.

Optional casefold is a flag specifying whether a lowercase alphabet is
acceptable as input.  For security purposes, the default is False.
{extra_args}
The result is returned as a bytes object.  A binascii.Error is raised if
the input is incorrectly padded or if there are non-alphabet
characters present in the input.
a´  
RFC 4648 allows for optional mapping of the digit 0 (zero) to the
letter O (oh), and for optional mapping of the digit 1 (one) to
either the letter I (eye) or letter L (el).  The optional argument
map01 when not None, specifies which letter the digit 1 should be
mapped to (when map01 is not None, the digit 0 is always mapped to
the letter O).  For security purposes the default is None, so that
0 and 1 are not allowed in the input.
s    ABCDEFGHIJKLMNOPQRSTUVWXYZ234567s    0123456789ABCDEFGHIJKLMNOPQRSTUVc                 ó°  • U [         ;  aE  U  Vs/ s H  n[        U45      PM     nnU VVs/ s H  oC  H  oTU-   PM	     M     snn[         U '   S n[        U[        5      (       d  [	        U5      R                  5       n[        U5      S-  nU(       a  USSU-
  -  -   n[        5       n[        R                  n[         U    n	[        S[        U5      S5       H8  nU" XUS-    5      n
XyU
S-	     XšS-	  S-     -   XšS-	  S-     -   XšS-     -   -  nM:     US:X  a  S	US
S & O#US:X  a  SUSS & OUS:X  a  SUSS & OUS:X  a  SUSS & [        U5      $ s  snf s  snnf )Né   ó    r   é   é   iÿ  é
   é   s   ======iúÿÿÿr+   s   ====éüÿÿÿé   s   ===éýÿÿÿé   ó   =éÿÿÿÿ)Ú_b32tab2r2   r   r   r    r!   r/   Ú	bytearrayÚintÚ
from_bytesÚrange)Úalphabetr&   ÚiÚb32tabÚaÚbÚleftoverr5   rQ   Úb32tab2Úcs              r'   Ú
_b32encoder[   ¦   s{  € ð ”xÓÙ'/Ó0¢x !”%˜˜–+¡xˆÐ0Ù-3ÔDªV¨»V¸ !œe¹V™e©VÒDŒ�ÑØˆä�aœ×%Ñ%Ü�q‹M×!Ñ!Ó#ˆÜ�1‹v˜‰z€HæØ�˜˜X™Ñ&Ñ&ˆÜ‹k€GÜ—‘€JÜ�xÑ €GÜ�1”c˜!“f˜aÖ ˆÙ�q˜A ™E�{Ó#ˆØ˜A ™GÑ$Ø "™W¨Ñ-Ñ.ñ/à "™W¨Ñ-Ñ.ñ/ð  ™IÑ&ñ'ñ 	Šñ !ð �1ƒ}Ø ˆ��‰Ø	�Q‹Øˆ��‰Ø	�Q‹Øˆ��‰Ø	�Q‹Øˆ��ˆÜ�‹>Ðùò; 1ùÛDs
   �E¬Ec                 óä  • U [         ;  a'  [        U 5       VVs0 s H  u  pEXT_M	     snn[         U '   [        U5      n[        U5      S-  (       a  [        R
                  " S5      eUbR  [        U5      n[        U5      S:X  d   [        U5      5       eUR                  [        R                  SSU-   5      5      nU(       a  UR                  5       n[        U5      nUR                  S5      nU[        U5      -
  n[        5       n[         U    n	[        S[        U5      S5       H3  n
XU
S-    nSn U H  nUS-  X�   -   nM     XŒR                  S5      -  nM5     US-  (       d  US
;  a  [        R
                  " S5      eU(       a3  U(       a,  WSU-  -  nUR                  S5      nSSU-  -
  S-  nUS U USS & [        U5      $ s  snnf ! [         a    [        R
                  " S	5      S ef = f)Né   zIncorrect paddingrG   s   01ó   OrL   r   rB   zNon-base32 digit found>   r   rG   rI   rK   é   é+   éûÿÿÿ)Ú_b32revÚ	enumerater(   r/   r-   ÚErrorr0   r1   r2   r3   ÚupperÚrstriprO   rR   ÚKeyErrorÚto_bytes)rS   r&   ÚcasefoldÚmap01ÚkÚvÚlÚpadcharsÚdecodedÚb32revrT   ÚquantaÚaccrZ   ÚlastrX   s                   r'   Ú
_b32decodert   É   sÖ  € ð ”wÓÜ.7¸Ô.AÔBÒ.A¡d a˜QšTÑ.AÒBŒ�ÑÜ Ó"€AÜ
ˆ1ƒv�‡zÜ�nŠnÐ0Ó1Ð1ð ÑÜ'¨Ó.ˆÜ�5‹z˜Q‹Ð+¤ U£Ó+ˆØ�K‰KœŸ™¨¨t°e©|Ó<Ó=ˆÞØ�G‰G‹Iˆô 	ˆA‹€AØ	�‰�‹€AØ”3�q“6‰z€Hä‹k€GÜ�XÑ€FÜ�1”c˜!“f˜aÖ ˆØ�a˜!‘e�ˆØˆð	EÛ�Ø˜a‘x 6¡9Ñ,’ñ ð 	—<‘< “?Ñ"Šñ !ð 	ˆ1‡u� Ó/Ü�nŠnÐ0Ó1Ð1Þ–GØ��H‘ÑˆØ�|‰|˜A‹ˆØ˜˜X™Ñ%¨!Ñ+ˆØ˜I˜X�ˆ��ˆÜ�‹>ÐùóO Cøô8 ó 	EÜ—.’.Ð!9Ó:ÀÐDð	Eús   ™GÄ2GÇ"G/c                 ó"   • [        [        U 5      $ ©N)r[   Ú_b32alphabetr%   s    r'   r	   r	   ÷   s   € Ü”l AÓ&Ð&r6   Úbase32)Úencodingc                 ó$   • [        [        XU5      $ rv   )rt   rw   )r&   ri   rj   s      r'   r
   r
   û   s   € Ü”l A°Ó7Ð7r6   )ry   Ú
extra_argsc                 ó"   • [        [        U 5      $ rv   )r[   Ú_b32hexalphabetr%   s    r'   r   r      s   € Ü”o qÓ)Ð)r6   Ú	base32hexc                 ó"   • [        [        X5      $ rv   )rt   r}   ©r&   ri   s     r'   r   r     s   € ä”o qÓ3Ð3r6   Ú c                 óJ   • [         R                  " U 5      R                  5       $ )zKEncode the bytes-like object s using Base16 and return a bytes object.
    )r-   Úhexlifyre   r%   s    r'   r   r     s   € ô ×Ò˜AÓ×$Ñ$Ó&Ð&r6   c                 óÖ   • [        U 5      n U(       a  U R                  5       n [        R                  " SU 5      (       a  [        R
                  " S5      e[        R                  " U 5      $ )aj  Decode the Base16 encoded bytes-like object or ASCII string s.

Optional casefold is a flag specifying whether a lowercase alphabet is
acceptable as input.  For security purposes, the default is False.

The result is returned as a bytes object.  A binascii.Error is raised if
s is incorrectly padded or if there are non-alphabet characters present
in the input.
s	   [^0-9A-F]zNon-base16 digit found)r(   re   ÚreÚsearchr-   rd   Ú	unhexlifyr€   s     r'   r   r     sN   € ô 	  Ó"€AÞØ�G‰G‹IˆÜ	‡y‚y�˜q×!Ñ!Ü�nŠnÐ5Ó6Ð6Ü×Ò˜aÓ Ð r6   s   <~s   ~>c                 ó  • [        U [        5      (       d  [        U 5      R                  5       n [	        U 5      * S-  nU(       a  U SU-  -   n [
        R                  " S[	        U 5      S-  -  5      R                  U 5      nU Vs/ s H<  nU(       a	  U(       d  SO(U(       a  US:X  a  SOX(S-     X(S-  S	-     -   XS-     -   PM>     n	nU(       a'  U(       d   U	S
   S:X  a  US   S-  U	S
'   U	S
   S U*  U	S
'   SR                  U	5      $ s  snf )NrK   rC   z!%dIó   zi    ó   yií^	 éU   i9  rM   r   rB   r6   )	r   r   r    r!   r/   ÚstructÚStructÚunpackÚjoin)
rW   ÚcharsÚchars2ÚpadÚfoldnulsÚ
foldspacesÚpaddingÚwordsÚwordÚchunkss
             r'   Ú	_85encoder™   .  s  € ä�aœ×%Ñ%Ü�q‹M×!Ñ!Ó#ˆä�A“ˆw˜!‰m€GÞØ�˜‘ÑˆÜ�MŠM˜&¤C¨£F¨a¡KÑ0Ó1×8Ñ8¸Ó;€Eñ  ó!ò
  �$ö ¦t‰dÞ  T¨ZÓ%7‰dØ˜f‘nÑ%Ø˜b‘j 4Ñ'Ñ(ñ)à˜B‘YÑñ ò!ñ
  ð ð !ö –sØ�"‰:˜ÓØ˜q™ A™ˆF�2‰JØ˜B‘Z 	 ' Ð*ˆˆr‰
à�8‰8�FÓÐùò!s   ÂAD	)r”   Úwrapcolr’   Úadobec                óL  • [         cP  [        SS5       Vs/ s H  n[        U45      PM     snq[         VV s/ s H  n[          H  oU -   PM	     M     sn nq [	        W [        [         USU5      nU(       a	  [
        U-   nU(       a}  [        U(       a  SOSU5      n[        S[        U5      U5       Vs/ s H	  nXuXR-    PM     nnU(       a&  [        US   5      S-   U:”  a  UR                  S5        S	R                  U5      nU(       a	  U[        -  nU$ s  snf s  sn nf s  snf )
a  Encode bytes-like object b using Ascii85 and return a bytes object.

foldspaces is an optional flag that uses the special short sequence 'y'
instead of 4 consecutive spaces (ASCII 0x20) as supported by 'btoa'. This
feature is not supported by the standard encoding used in PDF.

If wrapcol is non-zero, insert a newline (b'\n') character after at most
every wrapcol characters.

pad controls whether zero-padding applied to the end of the input
is fully retained in the output encoding, as done by btoa,
producing an exact multiple of 5 bytes of output.

adobe controls whether the encoded byte sequence is framed with <~
and ~>, as in a PostScript base-85 string literal.  Note that
while ASCII85Decode streams in PDF documents must be terminated
with ~>, they must not use a leading <~.

é!   év   Tr+   rG   r   rM   r6   ó   
)Ú
_a85chars2rR   r2   Ú	_a85charsr™   Ú	_A85STARTÚmaxr/   Úappendr�   Ú_A85END)	rW   r”   rš   r’   r›   rT   rV   Úresultr˜   s	            r'   r   r   F  s  € ô. ÑÜ*/°°C¬.Ó9ª. Q”U˜A˜4–[©.Ñ9ˆ	Ý'0ÔD¢y !¿)¸)°Q˜1”u¹)‘u¡yÒDˆ
ä�qœ)¤Z°°d¸JÓG€FæÜ˜VÑ#ˆÞÜž5‘a a¨Ó1ˆä  ¤C¨£K°Ô9ó;Ú9�að ˜A™KÓ(Ù9ð 	ð ;æÜ�6˜"‘:‹ Ñ" WÓ,Ø—‘˜cÔ"Ø—‘˜FÓ#ˆÞØ”'Ñˆà€Mùò% :ùÛDùò;s   –D¸DÂ4D!s    	
)r”   r›   Úignorecharsc                ó–  • [        U 5      n U(       a]  U R                  [        5      (       d  [        SR	                  [        5      5      eU R                  [        5      (       a  U SS n OU SS n [        R                  " S5      R                  n/ nUR                  n/ nUR                  nUR                  n	U S-    H¸  n
SU
s=::  a  S::  aJ  O  OGU" U
5        [        U5      S	:X  a.  S
nU H  n
SU-  U
S-
  -   nM      U" U" U5      5        U	" 5         MX  MZ  U
S:X  a  U(       a  [        S5      eU" S5        M|  U(       a"  U
S:X  a  U(       a  [        S5      eU" S5        M¥  X£;   a  M¬  [        SU
-  5      e   SR                  U5      nS[        U5      -
  nU(       a  USU*  nU$ ! [        R                   a    [        S5      Sef = f)a«  Decode the Ascii85 encoded bytes-like object or ASCII string b.

foldspaces is a flag that specifies whether the 'y' short sequence
should be accepted as shorthand for 4 consecutive spaces (ASCII
0x20).  This feature is not supported by the standard Ascii85
encoding used in PDF and PostScript.

adobe controls whether the <~ and ~> markers are present. While
the leading <~ is not required, the input must end with ~>, or a
ValueError is raised.

ignorechars should be a byte string containing characters to ignore from the
input. This should only contain whitespace characters, and by default
contains all whitespace characters in ASCII.

The result is returned as a bytes object.
z1Ascii85 encoded byte sequences must end with {!r}r+   éþÿÿÿNú!Is   uuuur�   éu   rB   r   r‹   zAscii85 overflowéz   zz inside Ascii85 5-tuples       éy   zy inside Ascii85 5-tuples       zNon-Ascii85 digit found: %cr6   rK   )r(   Úendswithr¥   r   ÚformatÚ
startswithr¢   rŒ   r�   Úpackr¤   Úclearr/   Úerrorr�   )rW   r”   r›   r§   ÚpackIro   Údecoded_appendÚcurrÚcurr_appendÚ
curr_clearÚxrr   r¦   r•   s                 r'   r   r   r  s¼  € ô$ 	  Ó"€AÞØ�z‰zœ'×"Ñ"Üðß"™F¤7›Oóð ð �<‰<œ	×"Ñ"Ø�!�B�‰Aà�#�2�ˆAô
 �MŠM˜$Ó×$Ñ$€EØ€GØ—^‘^€NØ€DØ—+‘+€KØ—‘€JØ�Œ\ˆØ�aÕ"˜7Ö"Ù˜ŒNÜ�4‹y˜A‹~Ø�Û�AØ˜s™( a¨"¡fÑ-’Cñ ðCÙ"¡5¨£:Ô.ñ –ñ ð �'‹\ÞÜ Ð!;Ó<Ð<Ù˜;Ö'Þ˜A ›LÞÜ Ð!;Ó<Ð<ÙÐ.Ö/ØÓáäÐ:¸QÑ>Ó?Ð?ñ1 ð4 �X‰X�gÓ€FØ”#�d“)‰m€GÞà˜	˜'˜Ð"ˆØ€Møô- —|‘|ó CÜ$Ð%7Ó8¸dÐBðCús   Ã>F'Æ'!GsU   0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~c                 óæ   • [         cJ  [         Vs/ s H  n[        U45      PM     snq[         VV s/ s H  n[          H  oU -   PM	     M     sn nq [	        W [        [         U5      $ s  snf s  sn nf )a  Encode bytes-like object b in base85 format and return a bytes object.

The input is padded with b' ' so its length is a multiple of 4
bytes before encoding.  If pad is true, all the resulting
characters are retained in the output, which will always be a
multiple of 5 bytes.
)Ú
_b85chars2Ú_b85alphabetr2   Ú	_b85charsr™   )rW   r’   rT   rV   s       r'   r   r   Â  s]   € ô ÑÝ*6Ó7ª, Q”U˜A˜4–[©,Ñ7ˆ	Ý'0ÔD¢y !¿)¸)°Q˜1”u¹)‘u¡yÒDˆ
Ü�Qœ	¤:¨sÓ3Ð3ùò 8ùÛDs
   �A(²A-c                 ó˜  • [         c$  S/S-  n[        [        5       H	  u  p#X!U'   M     Uq [        U 5      n [	        U 5      * S-  nU SU-  -   n / n[
        R                  " S5      R                  n[        S[	        U 5      S5       H=  nXUS-    nSn U H  nUS-  [         U   -   nM      UR                  U" U5      5        M?     S
R                  U5      n
U(       a  U
SU*  n
U
$ ! [         a1    [        U5       H   u  p“[         U   b  M  [        SX)-   -  5      Se   e f = f! [
        R                   a    [        S	U-  5      Sef = f)ziDecode the base85-encoded bytes-like object or ASCII string b

The result is returned as a bytes object.
Né   rB   ó   ~rª   r   r‹   z#bad base85 character at position %dz+base85 overflow in hunk starting at byte %dr6   )Ú_b85decrc   r¼   r(   r/   rŒ   r�   r±   rR   r"   r   r¤   r³   r�   )rW   Ú
b85dec_tmprT   rZ   r•   Úoutr´   Úchunkrr   Újr¦   s              r'   r   r   Ò  st  € ô �ð �V˜c‘\ˆ
ÜœlÖ+‰DˆAØ�q‹Mñ ,àˆä Ó"€AÜ�A“ˆw˜!‰m€GØ	ˆD�7‰NÑ€AØ
€CÜ�MŠM˜$Ó×$Ñ$€EÜ�1”c˜!“f˜aÖ ˆØ�A˜‘E�
ˆØˆð	Û�Ø˜B‘h¤¨¡Ñ+’ñ ð	,Ø�J‰J‘u˜S“zÖ"ñ !ð$ �X‰X�c‹]€FÞØ˜	˜'˜Ð"ˆØ€Møô ó 	Ü! %Ö(‘�Ü˜1‘:Ó%Ü$Ð%JØ'(¡uñ&.ó /Ø48ð9ñ )ð ð	ûô �|‰|ó 	,ÜÐJØ ñ!ó "Ø'+ð,ð	,ús   ÂC'Â,D%Ã'"D"ÄD"Ä%$E	sU   0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#s   ;_`|~rC   c                 ó>   • [        U 5      R                  [        5      $ )zCEncode bytes-like object b in z85 format and return a bytes object.)r   r1   Ú_z85_encode_translationr%   s    r'   r   r   	  s   € ä�Q‹<×!Ñ!Ô"9Ó:Ð:r6   c                 óÐ   • [        U 5      n U R                  [        5      n  [        U 5      $ ! [         a.  n[	        UR
                  S   R                  SS5      5      SeSnAff = f)zfDecode the z85-encoded bytes-like object or ASCII string b

The result is returned as a bytes object.
r   Úbase85Úz85N)r(   r1   Ú_z85_decode_translationr   r   ÚargsÚreplace)r&   Úes     r'   r   r     sa   € ô
 	  Ó"€AØ	�‰Ô+Ó,€AðGÜ˜‹|ÐøÜó GÜ˜Ÿ™ ™×*Ñ*¨8°UÓ;Ó<À$ÐFûðGús   ¢
- ­
A%·)A Á A%éL   rK   rI   c                 óÀ  • U R                  [        5      =n(       aÂ  [        U5      [        :  ai  U R                  [        [        U5      -
  5      =n(       aA  X#-  n[        U5      [        :  a*  U R                  [        [        U5      -
  5      =n(       a  MA  [        R                  " U5      nUR                  U5        U R                  [        5      =n(       a  MÁ  gg)z1Encode a file; input and output are binary files.N)ÚreadÚ
MAXBINSIZEr/   r-   r.   Úwrite)ÚinputÚoutputr&   ÚnsÚlines        r'   r   r      s¤   € à�z‰zœ*Ó%Ð
%ˆ!Õ
%Ü�!‹f”zÓ!¨U¯Z©Z¼
Ä3ÀqÃ6Ñ8IÓ-JÐ'J rÕ'JØ‰GˆAô �!‹f”zÓ!¨U¯Z©Z¼
Ä3ÀqÃ6Ñ8IÓ-JÐ'J r×'Jä×"Ò" 1Ó%ˆØ�‰�TÔð	 �z‰zœ*Ó%Ð
%ˆ!×
%Ñ
%r6   c                 ó´   • U R                  5       =n(       aA  [        R                  " U5      nUR                  U5        U R                  5       =n(       a  M@  gg)z1Decode a file; input and output are binary files.N)Úreadliner-   r9   rÓ   )rÔ   rÕ   r×   r&   s       r'   r   r   )  sF   € à—.‘.Ó"Ð
"ˆ$Õ
"Ü×Ò Ó%ˆØ�‰�QŒð —.‘.Ó"Ð
"ˆ$×
"Ñ
"r6   c                 ó�  •  [        U 5      nUR                  S;  a3  SUR                  < SU R                  R                  < 3n[        U5      eUR
                  S:w  a0  SUR
                  U R                  R                  4-  n[        U5      eg ! [         a*  nSU R                  R                  -  n[        U5      UeS nAff = f)Nz"expected bytes-like object, not %s)rZ   rW   ÚBz#expected single byte elements, not z from rG   z(expected 1-D data, not %d-D data from %s)r    r"   r#   r$   r¯   Úndim)r&   ÚmÚerrÚmsgs       r'   Ú_input_type_checkrà   /  s°   € ð&Ü�q‹Mˆð 	‡x�x�Ô&à+,¯8¬8°Q·[±[×5IÓ5IðKˆä˜‹nÐØ‡v�v�ƒ{Ø9Ø+,¯6©6°1·;±;×3GÑ3GÐ*HñIˆä˜‹nÐð øô ó &Ø2°Q·[±[×5IÑ5IÑIˆÜ˜‹n #Ð%ûð&ús   ‚B Â
CÂ%C Ã Cc                 óà   • [        U 5        / n[        S[        U 5      [        5       H3  nXU[        -    nUR	                  [
        R                  " U5      5        M5     SR                  U5      $ )zREncode a bytestring into a bytes object containing multiple lines
of base-64 data.r   r6   )rà   rR   r/   rÒ   r¤   r-   r.   r�   )r&   ÚpiecesrT   rÄ   s       r'   r   r   ?  s^   € ô �aÔØ€FÜ�1”c˜!“fœjÖ)ˆØ�aœ*‘nÐ%ˆØ�‰”h×)Ò)¨%Ó0Ö1ñ *ð �8‰8�FÓÐr6   c                 óD   • [        U 5        [        R                  " U 5      $ )z8Decode a bytestring of base-64 data into a bytes object.)rà   r-   r9   r%   s    r'   r   r   J  s   € ä�aÔÜ×Ò˜qÓ!Ð!r6   c                  ó|  • SSK n SSKnSU R                  S    S3n UR                  U R                  SS S5      u  p4[        nW H<  u  pxUS:X  a  [        nUS	:X  a  [        nUS
:X  a  [        nUS:X  d  M1  [        U5          g   W(       a>  US   S:w  a5  [        US   S5       n	U" X�R
                  R                  5        SSS5        gU R                  R                  5       (       a:  SSKn
U R                  R                  R                  5       nU
R!                  U5      nOU R                  R                  nU" XÀR
                  R                  5        g! UR                   aC  nU R                  U l        [        U5        [        U5        U R                  S5         SnAGNgSnAff = f! , (       d  f       g= f)zSmall main programr   Nzusage: zx [-h|-d|-e|-u] [file|-]
        -h: print this help message and exit
        -d, -u: decode
        -e: encode (default)rG   Úhdeur+   z-ez-dz-uz-hÚ-Úrb)ÚsysÚgetoptÚargvr³   ÚstderrÚstdoutÚprintÚexitr   r   ÚopenÚbufferÚstdinÚisattyÚiorÑ   ÚBytesIO)rè   ré   ÚusageÚoptsrÌ   rß   ÚfuncÚorV   Úfró   Údatarð   s                r'   Úmainrû   Q  sa  € çØ˜Ÿ™ ™�}ð %ð  €EðØ—]‘] 3§8¡8¨A¨B <°Ó8‰
ˆô €DÛ‰ˆØ�‹9œV�dØ�‹9œV�dØ�‹9œV�dØ��9”e˜E”l¡Fñ	 ö
 ��Q‘˜3“Ü�$�q‘'˜4Ô  AÙ�—J‘J×%Ñ%Ô&÷ !Ð ð �9‰9×Ñ×ÑãØ—9‘9×#Ñ#×(Ñ(Ó*ˆDØ—Z‘Z Ó%‰Fà—Y‘Y×%Ñ%ˆFÙˆV—Z‘Z×&Ñ&Õ'øð- �<‰<ó Ø—Z‘ZˆŒ
ÜˆcŒ
ÜˆeŒØ�‰��Šûð	ú÷ !Õ ús#   �!E Â%F-ÅF*Å'8F%Æ%F*Æ-
F;Ú__main__rv   )NF)FN)F)FFF)?Ú__doc__r…   rŒ   r-   Ú__all__r2   rO   r   r(   r   r   r   r   r3   r>   r@   r   r   Ú_B32_ENCODE_DOCSTRINGÚ_B32_DECODE_DOCSTRINGÚ_B32_DECODE_MAP01_DOCSTRINGrw   r}   rN   rb   r[   rt   r	   r¯   r
   r   r   r   r   r¡   r    r¢   r¥   r™   r   r   r¼   r½   r»   rÁ   r   r   Ú_z85alphabetÚ_z85_b85_decode_diffr/   rË   rÇ   r   r   ÚMAXLINESIZErÒ   r   r   rà   r   r   rû   r$   © r6   r'   Ú<module>r     s2  ðñ Kó 
Û Û ò€ð$ �iÐ €òKô"ô8ò4òð $Ÿo™o¨e°UÓ;Ð Ø#Ÿo™o¨e°UÓ;Ð ò?òð$Ð ð	Ð ðÐ ð 3€Ø5€Ø€Ø
€ò!ôF+ò\'à)×0Ñ0¸(Ð0ÐC€	Ô ô8à)×0Ñ0¸(Ø3Nð 1ð P€	Ô ò*à,×3Ñ3¸[Ð3ÐI€Ô ô4ð -×3Ñ3¸[Ø?Að 4ð C€Ô ò'ô!ð* €	Ø€
Ø€	Ø
€ôð0  %¨a°UÀ%õ *ðX  %¨E¸|õ FðTE€à€	Ø€
Ø
€ô4ò *ðXE€ð  Ð ØŸ/™/ØÐ'Ñ'Ø�7™SÐ!5Ó6Ñ6Ñ6óÐ ð  Ÿ/™/¨,¸ÓEÐ ò;ò
Gð  €Ø˜1‰n˜aÑ€
òòòò ò"ò(ðD ˆzÓÙ…Fð r6   