



UpperCamelCase__ =						"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"






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

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

						__lowercase					=				len(lowercase__   ) % 6 != 0

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






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

						# 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(lowercase__						,       lowercase__   ):
												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(lowercase__   ) % 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(lowercase__   )   )[2:].zfill(6   ) for char in encoded_data   )[: -padding * 2]
						else:
												__lowercase					=				"""""".join(
												    bin(B64_CHARSET.index(lowercase__   )   )[2:].zfill(6   ) for char in encoded_data   )

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

						return bytes(lowercase__   )


if __name__ == "__main__":
			import doctest

			doctest.testmod()










def  UpperCAmelCase__    (    lowercase__						,       lowercase__   ) ->      bool:
						__lowercase					=				len(lowercase__   )
						__lowercase					=				[[False] * (required_sum + 1) for _ in range(arr_len + 1   )]

						# for each arr value, a sum of zero(0) can be formed by not taking any element
						# hence True/1
						for i in range(arr_len + 1   ):
												__lowercase					=				True

						# sum is not zero and set is empty then false
						for i in range(1						,       required_sum + 1   ):
												__lowercase					=				False

						for i in range(1						,       arr_len + 1   ):
												for j in range(1						,       required_sum + 1   ):
																		if arr[i - 1] > j:
																								__lowercase					=				subset[i - 1][j]
																		if arr[i - 1] <= j:
																								__lowercase					=				subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

						return subset[arr_len][required_sum]


if __name__ == "__main__":
			import doctest

			doctest.testmod()





