


a					  =     'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'


def 			UpperCAmelCase_				(      UpperCAmelCase__  ):
					# Make sure the supplied data is a bytes-like object
					if not isinstance(UpperCAmelCase__						,							UpperCAmelCase__  ):
										lowercase_  							=			F'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
										raise TypeError(UpperCAmelCase__  )

					lowercase_  							=			"""""".join(bin(UpperCAmelCase__  )[2:].zfill(8  ) for byte in data  )

					lowercase_  							=			len(UpperCAmelCase__  ) % 6 != 0

					if padding_needed:
										# The padding that will be added later
										lowercase_  							=			B"""=""" * ((6 - len(UpperCAmelCase__  ) % 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(UpperCAmelCase__  ) % 6)
					else:
										lowercase_  							=			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(UpperCAmelCase__  )						,							6  )  ).encode()
					    + padding
					)


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

					# 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(UpperCAmelCase__						,							UpperCAmelCase__  ):
										try:
															lowercase_  							=			encoded_data.decode("""utf-8"""  )
										except UnicodeDecodeError:
															raise ValueError("""base64 encoded data should only contain ASCII characters"""  )

					lowercase_  							=			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(UpperCAmelCase__  ) % 4 == 0 and padding < 3, "Incorrect padding"

					if padding:
										# Remove padding if there is one
										lowercase_  							=			encoded_data[:-padding]

										lowercase_  							=			"""""".join(
										    bin(B64_CHARSET.index(UpperCAmelCase__  )  )[2:].zfill(6  ) for char in encoded_data  )[: -padding * 2]
					else:
										lowercase_  							=			"""""".join(
										    bin(B64_CHARSET.index(UpperCAmelCase__  )  )[2:].zfill(6  ) for char in encoded_data  )

					lowercase_  							=			[
					    int(binary_stream[index : index + 8]						,							2  )
					    for index in range(0						,							len(UpperCAmelCase__  )						,							8  )
					]

					return bytes(UpperCAmelCase__  )


if __name__ == "__main__":
							import doctest

							doctest.testmod()






def 			UpperCAmelCase_				(      UpperCAmelCase__  ):
					if not isinstance(UpperCAmelCase__						,							UpperCAmelCase__  ):
										raise TypeError("""Input value must be an 'int' type"""  )

					lowercase_  							=			0
					while number:
										position += 1
										number >>= 1

					return position


if __name__ == "__main__":
							import doctest

							doctest.testmod()


