



"""simple docstring"""






_lowercase : int      						=						"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"






def      snake_case__   (		__lowerCamelCase				:    bytes	):
			"""simple docstring"""
			# Make sure the supplied data is a bytes-like object
			if not isinstance(__lowerCamelCase							,		__lowerCamelCase	):
						lowerCamelCase__		:		Dict			=f'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
						raise TypeError(__lowerCamelCase	)

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

			lowerCamelCase__		:		Tuple			=len(__lowerCamelCase	) % 6 != 0

			if padding_needed:
						# The padding that will be added later
						lowerCamelCase__		:		Optional[int]			=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:
						lowerCamelCase__		:		Union[str, 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(__lowerCamelCase	)							,		6	)	).encode()
			    + padding
			)






def      snake_case__   (		__lowerCamelCase				:    str	):
			"""simple docstring"""
			# Make sure encoded_data is either a string or a bytes-like object
			if not isinstance(__lowerCamelCase							,		__lowerCamelCase	) and not isinstance(__lowerCamelCase							,		__lowerCamelCase	):
						lowerCamelCase__		:		Dict			=(
						    '''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:
									lowerCamelCase__		:		Union[str, Any]			=encoded_data.decode('''utf-8'''	)
						except UnicodeDecodeError:
									raise ValueError('''base64 encoded data should only contain ASCII characters'''	)

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

			if padding:
						# Remove padding if there is one
						lowerCamelCase__		:		Optional[Any]			=encoded_data[:-padding]

						lowerCamelCase__		:		Union[str, Any]			=''''''.join(
						    bin(B64_CHARSET.index(__lowerCamelCase	)	)[2:].zfill(6	) for char in encoded_data	)[: -padding * 2]
			else:
						lowerCamelCase__		:		List[str]			=''''''.join(
						    bin(B64_CHARSET.index(__lowerCamelCase	)	)[2:].zfill(6	) for char in encoded_data	)

			lowerCamelCase__		:		Union[str, Any]			=[
			    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 __future__ import annotations






def      snake_case__   (		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int	):
			"""simple docstring"""
			if b == 0:
						return (1, 0)
			((lowerCamelCase__)	,   (lowerCamelCase__))		:		Any			=extended_euclid(__lowerCamelCase							,		a % b	)
			lowerCamelCase__		:		Optional[Any]			=a // b
			return (y, x - k * y)






def      snake_case__   (		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int	):
			"""simple docstring"""
			((lowerCamelCase__)	,   (lowerCamelCase__))		:		Any			=extended_euclid(__lowerCamelCase							,		__lowerCamelCase	)
			lowerCamelCase__		:		List[Any]			=na * na
			lowerCamelCase__		:		Union[str, Any]			=ra * x * na + ra * y * na
			return (n % m + m) % m






def      snake_case__   (		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int	):
			"""simple docstring"""
			((lowerCamelCase__)	,   (lowerCamelCase__))		:		int			=extended_euclid(__lowerCamelCase							,		__lowerCamelCase	)
			if b < 0:
						lowerCamelCase__		:		Any			=(b % n + n) % n
			return b






def      snake_case__   (		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int							,		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__	,   lowerCamelCase__		:		Any			=invert_modulo(__lowerCamelCase							,		__lowerCamelCase	), invert_modulo(__lowerCamelCase							,		__lowerCamelCase	)
			lowerCamelCase__		:		Tuple			=na * na
			lowerCamelCase__		:		Optional[Any]			=ra * x * na + ra * y * na
			return (n % m + m) % m


if __name__ == "__main__":
		from doctest import testmod

		testmod(name="chinese_remainder_theorem", verbose=True)
		testmod(name="chinese_remainder_theorem2", verbose=True)
		testmod(name="invert_modulo", verbose=True)
		testmod(name="extended_euclid", verbose=True)




