





'''simple docstring'''

__lowerCamelCase : Optional[Any]											=			"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				if not isinstance(lowerCAmelCase_		,							lowerCAmelCase_							):
								lowercase         = f'a bytes-like object is required, not \'{data.__class__.__name__}\''
								raise TypeError(lowerCAmelCase_							)

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

				lowercase         = len(lowerCAmelCase_							) % 6 != 0

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







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				if not isinstance(lowerCAmelCase_		,							lowerCAmelCase_							) and not isinstance(lowerCAmelCase_		,							lowerCAmelCase_							):
								lowercase         = (
								    "argument should be a bytes-like object or ASCII string, "
								    f'not \'{encoded_data.__class__.__name__}\''
								)
								raise TypeError(lowerCAmelCase_							)

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

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

				return bytes(lowerCAmelCase_							)


if __name__ == "__main__":
			import doctest

			doctest.testmod()











'''simple docstring'''

from functools import lru_cache







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				lowercase         = 2
				lowercase         = set()
				while i * i <= n:
								if n % i:
												i += 1
								else:
												n //= i
												factors.add(lowerCAmelCase_							)
				if n > 1:
								factors.add(lowerCAmelCase_							)
				return factors







@lru_cache
def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				return len(unique_prime_factors(lowerCAmelCase_							)							)







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				return len(set(lowerCAmelCase_							)							) in (0, 1)







def 							UpperCAmelCase_    (	lowerCAmelCase_							):

				"""simple docstring"""






				lowercase         = 2

				while True:
								# Increment each value of a generated range
								lowercase         = [base + i for i in range(lowerCAmelCase_							)]

								# Run elements through out unique_prime_factors function
								# Append our target number to the end.
								lowercase         = [upf_len(lowerCAmelCase_							) for x in group]
								checker.append(lowerCAmelCase_							)

								# If all numbers in the list are equal, return the group variable.
								if equality(lowerCAmelCase_							):
												return group

								# Increment our base variable by 1
								base += 1







def 							UpperCAmelCase_    (	lowerCAmelCase_ = 4							):

				"""simple docstring"""






				lowercase         = run(lowerCAmelCase_							)
				return results[0] if len(lowerCAmelCase_							) else None


if __name__ == "__main__":
			print(solution())




