





lowercase      :       Any									=  """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""



def A_	(		A__				)  ->		bytes:
       # Make sure the supplied data is a bytes-like object
       if not isinstance(A__		,      A__				):
              a__						:	List[Any] =				F'a bytes-like object is required, not \'{data.__class__.__name__}\''
              raise TypeError(A__				)

       a__						:	str =				''.join(bin(A__				)[2:].zfill(8				) for byte in data				)

       a__						:	List[Any] =				len(A__				) % 6 != 0

       if padding_needed:
              # The padding that will be added later
              a__						:	str =				B'=' * ((6 - len(A__				) % 6) // 2)

              # Append binary_stream with arbitrary binary digits (0's by default) to make its
              # length a multiple of 6.
              binary_stream += "0" * (6 - len(A__				) % 6)
       else:
              a__						:	Any =				B''

       # Encode every 6 binary digits to their corresponding Base64 character
       return (
           "".join(
               B64_CHARSET[int(binary_stream[index : index + 6]		,      2				)]
               for index in range(0		,      len(A__				)		,      6				)				).encode()
           + padding
       )



def A_	(		A__				)  ->		bytes:
       # Make sure encoded_data is either a string or a bytes-like object
       if not isinstance(A__		,      A__				) and not isinstance(A__		,      A__				):
              a__						:	int =				(
                  'argument should be a bytes-like object or ASCII string, '
                  F'not \'{encoded_data.__class__.__name__}\''
              )
              raise TypeError(A__				)

       # In case encoded_data is a bytes-like object, make sure it contains only
       # ASCII characters so we convert it to a string object
       if isinstance(A__		,      A__				):
              try:
                     a__						:	Optional[int] =				encoded_data.decode('utf-8'				)
              except UnicodeDecodeError:
                     raise ValueError('base64 encoded data should only contain ASCII characters'				)

       a__						:	List[Any] =				encoded_data.count('='				)

       # Check if the encoded string contains non base64 characters
       if padding:
              assert all(
                  char in B64_CHARSET for char in encoded_data[:-padding]				), "Invalid base64 character(s) found."
       else:
              assert all(
                  char in B64_CHARSET for char in encoded_data				), "Invalid base64 character(s) found."

       # Check the padding
       assert len(A__				) % 4 == 0 and padding < 3, "Incorrect padding"

       if padding:
              # Remove padding if there is one
              a__						:	Optional[int] =				encoded_data[:-padding]

              a__						:	Optional[int] =				''.join(
                  bin(B64_CHARSET.index(A__				)				)[2:].zfill(6				) for char in encoded_data				)[: -padding * 2]
       else:
              a__						:	Optional[int] =				''.join(
                  bin(B64_CHARSET.index(A__				)				)[2:].zfill(6				) for char in encoded_data				)

       a__						:	Any =				[
           int(binary_stream[index : index + 8]		,      2				)
           for index in range(0		,      len(A__				)		,      8				)
       ]

       return bytes(A__				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()









from math import loga



def A_	(		A__				)  ->		int:
       if a < 0:
              raise ValueError('Input value must be a positive integer'				)
       elif isinstance(A__		,      A__				):
              raise TypeError('Input value must be a \'int\' type'				)
       return 0 if (a == 0) else int(loga(a & -a				)				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()


