HEX
Server: LiteSpeed
System: Linux s787.bom1.mysecurecloudhost.com 4.18.0-477.13.1.lve.el8.x86_64 #1 SMP Thu Jun 1 16:40:47 EDT 2023 x86_64
User: mobilech (5348)
PHP: 8.1.34
Disabled: NONE
Upload Files
File: //proc/thread-self/root/opt/alt/python313/lib64/python3.13/__pycache__/base64.cpython-313.opt-1.pyc
�

�*j:W����SrSSKrSSKrSSKr/SQr\\4rSrS:Sjr	S;Sjr
SrS	r\RS
S5r\RSS
5rSrS
rSrSrSrSrSr0r0rSrS<SjrSr\R9SS9\lS<Sjr\R9S\S9\lSr\R9SS9\lS=Sjr\R9SSS9\lSr S=Sjr!Sq"Sq#S r$S!r%S>S"jr&SSSSS#.S$jr'SSS%S&.S'jr(S(r)Sq*Sq+Sq,S=S)jr-S*r.S+r/S,r0\R\/\0-\)S-\1"\05--5r2\R\)\/5r3S.r4S/r5S0r6\6S1-S2-r7S3r8S4r9S5r:S6r;S7r<S8r=\>S9:Xa\="5 gg)?zDBase16, Base32, Base64 (RFC 3548), 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(aURS5$[U[
5(aU$[
U5R5$![a [	S5ef=f![a$ [SURR-5Sef=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 �-/opt/alt/python313/lib64/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"USS9nUb%UR[R	SU55$U$)aEncode 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�	translate�bytes�	maketrans)r&�altchars�encodeds   r'rr3s=���!�!�!�U�3�G���� � ������!A�B�B��N�Fc��[U5nUb0[U5nUR[RUS55n[R
"XS9$)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+)�strict_mode)r(r.r/r0r,�
a2b_base64)r&r1�validates   r'rrAsH��$	 ��"�A���*�8�4��
�K�K�����%�8�9�����q�7�7r3c��[U5$)zjEncode bytes-like object s using the standard Base64 alphabet.

The result is returned as a bytes object.
)rr%s r'rr[s��
�Q�<�r3c��[U5$)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.
)rr%s r'rrbs���Q�<�r3r+s-_c�>�[U5R[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
'/'.
)rr.�_urlsafe_encode_translationr%s r'rrps���Q�<�!�!�"=�>�>r3c�X�[U5nUR[5n[U5$)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(r.�_urlsafe_decode_translationrr%s r'rrys'��	 ��"�A�	���/�0�A��Q�<�r3zK
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 3548 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[;aEUVs/sHn[U45PM nnUVVs/sHoCHoTU-PM	 M snn[U'Sn[U[5(d[	U5R5n[
U5S-nU(aUSSU-
--n[5n[Rn[Un	[S[
U5S5H8nU"XUS-5n
XyU
S-	X�S-	S--X�S-	S--X�S---
nM: US:XaS	US
S&O#US:XaSUS
S&OUS:XaSUSS&OUS:XaSUSS&[U5$s snfs snnf)N��r��i��
�s======i�����s====����s===�����=���)�_b32tab2r/rrr r!�len�	bytearray�int�
from_bytes�range)�alphabetr&�i�b32tab�a�b�leftoverr2rP�b32tab2�cs           r'�
_b32encoderZ�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
�Ec��U[;a'[U5VVs0sHupEXT_M	 snn[U'[U5n[U5S-(a[R
"S5eUb3[U5nUR
[RSSU-55nU(aUR5n[U5nURS5nU[U5-
n[5n[Un	[S[U5S5H3n
XU
S-nSnUH
n
US-X�-nM X�RS5-
nM5 US-(dUS	;a[R
"S5eU(a3U(a,WSU--nURS5nS
SU--
S-nUSUUSS&[U5$s snnf![a [R
"S5Sef=f)N�zIncorrect paddings01�OrJrr?zNon-base32 digit found>rrDrGrI��+���)�_b32rev�	enumerater(rMr,�Errorr.r/r0�upper�rstriprNrQ�KeyError�to_bytes)rRr&�casefold�map01�k�v�l�padchars�decoded�b32revrS�quanta�accrY�lastrWs                r'�
_b32decoders�s����w��.7��.A�B�.A�d�a�Q�T�.A�B������"�A�
�1�v��z��n�n�0�1�1�
��'��.��
�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��������>���OC��8�	E��.�.�!9�:��D�	E�s�F(�F.�."Gc�"�[[U5$�N)rZ�_b32alphabetr%s r'r	r	�s���l�A�&�&r3�base32)�encodingc�$�[[XU5$ru)rsrv)r&rhris   r'r
r
�s���l�A��7�7r3)rx�
extra_argsc�"�[[U5$ru)rZ�_b32hexalphabetr%s r'rrs���o�q�)�)r3�	base32hexc�"�[[X5$ru)rsr|�r&rhs  r'rrs���o�q�3�3r3�c�J�[R"U5R5$)zKEncode the bytes-like object s using Base16 and return a bytes object.
    )r,�hexlifyrdr%s r'r
r
s�����A��$�$�&�&r3c���[U5nU(aUR5n[R"SU5(a[R
"S5e[R"U5$)ajDecode 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]zNon-base16 digit found)r(rd�re�searchr,rc�	unhexlifyrs  r'rrsN��	 ��"�A��
�G�G�I��	�y�y��q�!�!��n�n�5�6�6����a� � r3s<~s~>c��[U[5(d[U5R5n[	U5*S-nU(aUSU--n[
R"S[	U5S--5RU5nUVs/sH<nU(a	U(dSO(U(aUS:XaSOX(S-X(S-S	--XS--PM> n	nU(a'U(d U	S
S:XaUSS-U	S
'U	S
SU*U	S
'S
RU	5$s snf)NrIr@z!%dI�zi    �yi�^	�Ui9rKrr?r3)	rrr r!rM�struct�Struct�unpack�join)
rV�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�AD	)r��wrapcolr��adobec�L�[cP[SS5Vs/sHn[U45PM snq[VVs/sHn[HoU-PM	 M snnq[	W[[USU5nU(a	[
U-nU(a}[
U(aSOSU5n[S[U5U5Vs/sH	nXuXR-PM nnU(a&[US5S-U:�aURS5 S	RU5nU(a	U[-
nU$s snfs snnfs snf)
aEncode 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 <~.

�!�vTrErDrrKr3�
)�
_a85chars2rQr/�	_a85charsr��	_A85START�maxrM�appendr��_A85END)	rVr�r�r�r�rSrU�resultr�s	         r'rrFs��.��*/��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�4D!s 	

)r�r��ignorecharsc��[U5nU(a]UR[5(d[SR	[55eUR[5(aUSSnOUSSn[R"S5Rn/nURn/nURnURn	US-H�n
SU
s=::aS::aJO OGU"U
5 [U5S	:Xa.S
nUHn
SU-U
S-
-nM U"U"U55 U	"5 MXMZU
S
:XaU(a[S5eU"S5 M|U(a"U
S:XaU(a[S5eU"S5 M�X�;aM�[SU
-5e SRU5nS[U5-
n
U
(aUSU
*nU$![Ra
 [S5Sef=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}rE���N�!Isuuuur��ur?rr�zAscii85 overflow�zzz inside Ascii85 5-tuples�yzy inside Ascii85 5-tuples    zNon-Ascii85 digit found: %cr3rI)r(�endswithr�r�format�
startswithr�r�r��packr��clearrM�errorr�)rVr�r�r��packIrn�decoded_append�curr�curr_append�
curr_clear�xrqr�r�s              r'rrrs���$	 ��"�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'�'!GsU0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~c���[cJ[Vs/sHn[U45PM snq[VVs/sHn[HoU-PM	 M snnq[	W[[U5$s snfs snnf)aEncode 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�_b85alphabetr/�	_b85charsr�)rVr�rSrUs    r'rr�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[[5H	up#X!U'M Uq[U5n[	U5*S-nUSU--n/n[
R"S5Rn[S[	U5S5H=nXUS-nSnUHnUS-[U-nM URU"U55 M? S
RU5n
U(aU
SU*n
U
$![a1 [U5H up�[UbM[SX)--5Se ef=f![
Ra [S	U-5Sef=f)ziDecode the base85-encoded bytes-like object or ASCII string b

The result is returned as a bytes object.
N�r?�~r�rr�z#bad base85 character at position %dz+base85 overflow in hunk starting at byte %dr3)�_b85decrbr�r(rMr�r�r�rQr"rr�r�r�)rV�
b85dec_tmprSrYr��outr��chunkrq�jr�s           r'rr�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	sU0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#s;_`|~r@c�>�[U5R[5$)zCEncode bytes-like object b in z85 format and return a bytes object.)rr.�_z85_encode_translationr%s r'rr	s���Q�<�!�!�"9�:�:r3c���[U5nUR[5n[U5$![a.n[	UR
SR
SS55SeSnAff=f)zfDecode the z85-encoded bytes-like object or ASCII string b

The result is returned as a bytes object.
r�base85�z85N)r(r.�_z85_decode_translationrr�args�replace)r&�es  r'rr
sa��
	 ��"�A�	���+�,�A�G���|����G�������*�*�8�U�;�<�$�F��G�s�
-�
A%�)A � A%�LrIrGc��UR[5=n(a�[U5[:aiUR[[U5-
5=n(aAX#-
n[U5[:a*UR[[U5-
5=n(aMA[R"U5nURU5 UR[5=n(aM�gg)z1Encode a file; input and output are binary files.N)�read�
MAXBINSIZErMr,r-�write)�input�outputr&�ns�lines     r'rr 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�*�%�
%�!�
%�
%r3c��UR5=n(aA[R"U5nURU5 UR5=n(aM@gg)z1Decode a file; input and output are binary files.N)�readliner,r6r�)r�r�r�r&s    r'rr)sF���.�.�"�
"�$�
"�����%�����Q���.�.�"�
"�$�
"�
"r3c��[U5nURS;a3SUR<SURR<3n[U5eUR
S:wa0SUR
URR4-n[U5eg![a*nSURR-n[U5UeSnAff=f)Nz"expected bytes-like object, not %s)rYrV�Bz#expected single byte elements, not z from rDz(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�Cc���[U5 /n[S[U5[5H3nXU[-nUR	[
R"U55 M5 SRU5$)zREncode a bytestring into a bytes object containing multiple lines
of base-64 data.rr3)r�rQrMr�r�r,r-r�)r&�piecesrSr�s    r'rr?s^���a��
�F�
�1�c�!�f�j�
)���a�*�n�%���
�
�h�)�)�%�0�1�*��8�8�F��r3c�D�[U5 [R"U5$)z8Decode a bytestring of base-64 data into a bytes object.)r�r,r6r%s r'rrJs���a�����q�!�!r3c�|�SSKnSSKnSURSS3nURURSSS5up4[nWH<upxUS:Xa[nUS	:Xa[nUS
:Xa[nUS:XdM1[
U5  g W(a>USS:wa5[USS
5n	U"X�R
R5 SSS5 gURR5(a:SSKn
URRR5nU
R!U5nOURRnU"X�R
R5 g!URaCnURUl[
U5 [
U5 URS5 SnAGNgSnAff=f!,(df   g=f)zSmall main programrNzusage: zx [-h|-d|-e|-u] [file|-]
        -h: print this help message and exit
        -d, -u: decode
        -e: encode (default)rD�hdeurEz-ez-dz-uz-h�-�rb)�sys�getopt�argvr��stderr�stdout�print�exitrr�open�buffer�stdin�isatty�ior��BytesIO)
r�r��usage�optsr�r��func�orU�fr��datar�s
             r'�mainr�Qsa���������}�%�
 �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__ru)NF)FN)F)FFF)?�__doc__r�r�r,�__all__r/rNrr(rrrrr0r;r=rr�_B32_ENCODE_DOCSTRING�_B32_DECODE_DOCSTRING�_B32_DECODE_MAP01_DOCSTRINGrvr|rLrarZrsr	r�r
rrr
rr�r�r�r�r�rrr�r�r�r�rr�_z85alphabet�_z85_b85_decode_diffrMr�r�rr�MAXLINESIZEr�rrr�rrr�r$�r3r'�<module>rs2��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�TE���	�
�
�
��4� *�XE�� ���/�/��'�'��7�S�!5�6�6�6��� �/�/�,��E��;�
G� ���1�n�a�
�
���
� �"�(�D�z���F�r3