




UpperCAmelCase_		:				Union[str, Any]									=     'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'




def 		lowerCAmelCase_   (	lowerCamelCase   ):
				# Make sure the supplied data is a bytes-like object
				if not isinstance(_A	,     _A   ):
								__magic_name__	:	str								=F"a bytes-like object is required, not \'{data.__class__.__name__}\'"
								raise TypeError(_A   )

				__magic_name__	:	Any								="""""".join(bin(_A   )[2:].zfill(8   ) for byte in data   )

				__magic_name__	:	Any								=len(_A   ) % 6 != 0

				if padding_needed:
								# The padding that will be added later
								__magic_name__	:	Optional[Any]								=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:
								__magic_name__	:	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 		lowerCAmelCase_   (	lowerCamelCase   ):
				# Make sure encoded_data is either a string or a bytes-like object
				if not isinstance(_A	,     _A   ) and not isinstance(_A	,     _A   ):
								__magic_name__	:	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:
												__magic_name__	:	Dict								=encoded_data.decode("""utf-8"""   )
								except UnicodeDecodeError:
												raise ValueError("""base64 encoded data should only contain ASCII characters"""   )

				__magic_name__	:	List[str]								=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
								__magic_name__	:	List[Any]								=encoded_data[:-padding]

								__magic_name__	:	Optional[Any]								="""""".join(
								    bin(B64_CHARSET.index(_A   )   )[2:].zfill(6   ) for char in encoded_data   )[: -padding * 2]
				else:
								__magic_name__	:	int								="""""".join(
								    bin(B64_CHARSET.index(_A   )   )[2:].zfill(6   ) for char in encoded_data   )

				__magic_name__	:	List[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 pow, sqrt




def 		lowerCAmelCase_   (	*lowerCamelCase   ):
				__magic_name__	:	Tuple								=len(lowerCamelCase   ) > 0 and all(value > 0.0 for value in values   )
				return result




def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase   ):
				return (
				    round(sqrt(molar_mass_a / molar_mass_a   )	,     6   )
				    if validate(lowerCamelCase	,     lowerCamelCase   )
				    else ValueError("""Input Error: Molar mass values must greater than 0."""   )
				)




def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   ):
				return (
				    round(effusion_rate * sqrt(molar_mass_a / molar_mass_a   )	,     6   )
				    if validate(lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   )
				    else ValueError(
				        """Input Error: Molar mass and effusion rate values must greater than 0."""   )
				)




def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   ):
				return (
				    round(effusion_rate / sqrt(molar_mass_a / molar_mass_a   )	,     6   )
				    if validate(lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   )
				    else ValueError(
				        """Input Error: Molar mass and effusion rate values must greater than 0."""   )
				)




def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   ):
				return (
				    round(molar_mass / pow(effusion_rate_a / effusion_rate_a	,     2   )	,     6   )
				    if validate(lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   )
				    else ValueError(
				        """Input Error: Molar mass and effusion rate values must greater than 0."""   )
				)




def 		lowerCAmelCase_   (	lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   ):
				return (
				    round(pow(effusion_rate_a / effusion_rate_a	,     2   ) / molar_mass	,     6   )
				    if validate(lowerCamelCase	,     lowerCamelCase	,     lowerCamelCase   )
				    else ValueError(
				        """Input Error: Molar mass and effusion rate values must greater than 0."""   )
				)




