





_SCREAMING_SNAKE_CASE 		=						"""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""


def 							SCREAMING_SNAKE_CASE__  (      __a				):
	# Make sure the supplied data is a bytes-like object
	if not isinstance(__a				,	__a				):
		snake_case_						:     Union[str, Any]     =		f"""a bytes-like object is required, not '{data.__class__.__name__}'"""
		raise TypeError(__a				)

	snake_case_						:     Dict     =		''.join(bin(__a				)[2:].zfill(8				) for byte in data				)

	snake_case_						:     List[Any]     =		len(__a				) % 6 != 0

	if padding_needed:
		# The padding that will be added later
		snake_case_						:     List[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:
		snake_case_						:     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 							SCREAMING_SNAKE_CASE__  (      __a				):
	# Make sure encoded_data is either a string or a bytes-like object
	if not isinstance(__a				,	__a				) and not isinstance(__a				,	__a				):
		snake_case_						:     Tuple     =		(
		    '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:
			snake_case_						:     Union[str, Any]     =		encoded_data.decode('utf-8'				)
		except UnicodeDecodeError:
			raise ValueError('base64 encoded data should only contain ASCII characters'				)

	snake_case_						:     Union[str, 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
		snake_case_						:     Optional[int]     =		encoded_data[:-padding]

		snake_case_						:     Tuple     =		''.join(
		    bin(B64_CHARSET.index(__a				)				)[2:].zfill(6				) for char in encoded_data				)[: -padding * 2]
	else:
		snake_case_						:     List[str]     =		''.join(
		    bin(B64_CHARSET.index(__a				)				)[2:].zfill(6				) for char in encoded_data				)

	snake_case_						:     int     =		[
	    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()








def 							SCREAMING_SNAKE_CASE__  (      __a = 60_08_51_47_51_43				):

	try:
		snake_case_						:     Optional[Any]     =		int(__a				)
	except (TypeError, ValueError):
		raise TypeError('Parameter n must be int or castable to int.'				)
	if n <= 0:
		raise ValueError('Parameter n must be greater than or equal to one.'				)
	snake_case_						:     Any     =		2
	snake_case_						:     Any     =		0
	if n == 2:
		return 2
	while n > 2:
		while n % i != 0:
			i += 1
		snake_case_						:     Tuple     =		i
		while n % i == 0:
			snake_case_						:     List[str]     =		n // i
		i += 1
	return int(__a				)


if __name__ == "__main__":
						print(F'''{solution() = }''')

