






SCREAMING_SNAKE_CASE__      :			Optional[int]							=		"""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""

def      __lowercase					( snake_case ):







				"""simple docstring"""






				if not isinstance(snake_case,  snake_case ):
								__magic_name__		:Optional[Any]        =      f'''a bytes-like object is required, not \'{data.__class__.__name__}\''''
								raise TypeError(snake_case )

				__magic_name__		:Optional[Any]        =      ''''''.join(bin(snake_case )[2:].zfill(8 ) for byte in data )

				__magic_name__		:Tuple        =      len(snake_case ) % 6 != 0

				if padding_needed:
								# The padding that will be added later
								__magic_name__		:str        =      B'''=''' * ((6 - len(snake_case ) % 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(snake_case ) % 6)
				else:
								__magic_name__		: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(snake_case ),  6 ) ).encode()
				    + padding
				)

def      __lowercase					( snake_case ):







				"""simple docstring"""






				if not isinstance(snake_case,  snake_case ) and not isinstance(snake_case,  snake_case ):
								__magic_name__		:List[Any]        =      (
								    '''argument should be a bytes-like object or ASCII string, '''
								    f'''not \'{encoded_data.__class__.__name__}\''''
								)
								raise TypeError(snake_case )

				# 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(snake_case,  snake_case ):
								try:
												__magic_name__		:Union[str, Any]        =      encoded_data.decode('''utf-8''' )
								except UnicodeDecodeError:
												raise ValueError('''base64 encoded data should only contain ASCII characters''' )

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

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

								__magic_name__		:List[Any]        =      ''''''.join(
								    bin(B64_CHARSET.index(snake_case ) )[2:].zfill(6 ) for char in encoded_data )[: -padding * 2]
				else:
								__magic_name__		:Any        =      ''''''.join(
								    bin(B64_CHARSET.index(snake_case ) )[2:].zfill(6 ) for char in encoded_data )

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

				return bytes(snake_case )


if __name__ == "__main__":
					import doctest

					doctest.testmod()














from __future__ import annotations

def      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				__magic_name__		:Tuple        =      0
				__magic_name__		:Tuple        =      len(snake_case ) - 1

				while i < j:
								if nums[i] + nums[j] == target:
												return [i, j]
								elif nums[i] + nums[j] < target:
												__magic_name__		:str        =      i + 1
								else:
												__magic_name__		:List[Any]        =      j - 1

				return []


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					print(f"{two_pointer([2, 7, 11, 15], 9) = }")






