import struct

import binascii

__all__ = [

]

bytes_types = (bytes, bytearray) # Types acceptable as binary data

def _bytes_from_decode_data(s):

"string, not %r" % s.__class__.__name__) from None

def b64encode(s, altchars=None):

return encoded

def b64decode(s, altchars=None, validate=False):

return binascii.a2b_base64(s, strict_mode=validate)

def standard_b64encode(s):

return b64encode(s)

def standard_b64decode(s):

return b64decode(s)

_urlsafe_encode_translation = bytes.maketrans(b'+/', b'-_')

_urlsafe_decode_translation = bytes.maketrans(b'-_', b'+/')

def urlsafe_b64encode(s):

return b64encode(s).translate(_urlsafe_encode_translation)

def urlsafe_b64decode(s):

return b64decode(s)

_B32_ENCODE_DOCSTRING = '''

_B32_DECODE_DOCSTRING = '''

_B32_DECODE_MAP01_DOCSTRING = '''

_b32alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'

_b32hexalphabet = b'0123456789ABCDEFGHIJKLMNOPQRSTUV'

_b32tab2 = {}

_b32rev = {}

def _b32encode(alphabet, s):

return bytes(encoded)

def _b32decode(alphabet, s, casefold=False, map01=None):

return bytes(decoded)

def b32encode(s):

return _b32encode(_b32alphabet, s)

b32encode.__doc__ = _B32_ENCODE_DOCSTRING.format(encoding='base32')

def b32decode(s, casefold=False, map01=None):

return _b32decode(_b32alphabet, s, casefold, map01)

b32decode.__doc__ = _B32_DECODE_DOCSTRING.format(encoding='base32',

extra_args=_B32_DECODE_MAP01_DOCSTRING)

def b32hexencode(s):

return _b32encode(_b32hexalphabet, s)

b32hexencode.__doc__ = _B32_ENCODE_DOCSTRING.format(encoding='base32hex')

def b32hexdecode(s, casefold=False):

# base32hex does not have the 01 mapping

return _b32decode(_b32hexalphabet, s, casefold)

b32hexdecode.__doc__ = _B32_DECODE_DOCSTRING.format(encoding='base32hex',

extra_args='')

def b16encode(s):

"""Encode the bytes-like object s using Base16 and return a bytes object.

return binascii.hexlify(s).upper()

def b16decode(s, casefold=False):

return binascii.unhexlify(s)

_a85chars = None

_a85chars2 = None

_A85START = b"<~"

_A85END = b"~>"

def _85encode(b, chars, chars2, pad=False, foldnuls=False, foldspaces=False):

return b''.join(chunks)

def a85encode(b, *, foldspaces=False, wrapcol=0, pad=False, adobe=False):

return result

def a85decode(b, *, foldspaces=False, adobe=False, ignorechars=b' \t\n\r\v'):

return result

_b85alphabet = (b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

b"abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~")

_b85chars = None

_b85chars2 = None

_b85dec = None

def b85encode(b, pad=False):

return _85encode(b, _b85chars, _b85chars2, pad)

def b85decode(b):

return result

_z85alphabet = (b'0123456789abcdefghijklmnopqrstuvwxyz'

b'ABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#')

_z85_b85_decode_diff = b';_`|~'

_z85_decode_translation = bytes.maketrans(

_z85alphabet + _z85_b85_decode_diff,

_b85alphabet + b'\x00' * len(_z85_b85_decode_diff)

)

_z85_encode_translation = bytes.maketrans(_b85alphabet, _z85alphabet)

def z85encode(s):

"""Encode bytes-like object b in z85 format and return a bytes object."""

return b85encode(s).translate(_z85_encode_translation)

def z85decode(s):

raise ValueError(e.args[0].replace('base85', 'z85')) from None

MAXLINESIZE = 76 # Excluding the CRLF

MAXBINSIZE = (MAXLINESIZE//4)*3

def encode(input, output):

output.write(line)

def decode(input, output):

output.write(s)

def _input_type_check(s):

raise TypeError(msg)

def encodebytes(s):

return b"".join(pieces)

def decodebytes(s):

"""Decode a bytestring of base-64 data into a bytes object."""

_input_type_check(s)

return binascii.a2b_base64(s)

def main():

func(buffer, sys.stdout.buffer)

if __name__ == '__main__':

main()