





lowercase_					     =	"""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     bytes:
  # Make sure the supplied data is a bytes-like object
  if not isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    lowercase__			    =						F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
    raise TypeError(_SCREAMING_SNAKE_CASE	)

  lowercase__			    =						''.join(bin(_SCREAMING_SNAKE_CASE	)[2:].zfill(8	) for byte in data	)

  lowercase__			    =						len(_SCREAMING_SNAKE_CASE	) % 6 != 0

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




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     bytes:
  # Make sure encoded_data is either a string or a bytes-like object
  if not isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	) and not isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    lowercase__			    =						(
        'argument should be a bytes-like object or ASCII string, '
        F"""not '{encoded_data.__class__.__name__}'"""
    )
    raise TypeError(_SCREAMING_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(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    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(_SCREAMING_SNAKE_CASE	) % 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(_SCREAMING_SNAKE_CASE	)	)[2:].zfill(6	) for char in encoded_data	)[: -padding * 2]
  else:
    lowercase__			    =						''.join(
        bin(B64_CHARSET.index(_SCREAMING_SNAKE_CASE	)	)[2:].zfill(6	) for char in encoded_data	)

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

  return bytes(_SCREAMING_SNAKE_CASE	)


if __name__ == "__main__":
      import doctest

      doctest.testmod()









import math




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     List[Any]:
  if 0 not in (x, y):
    # We use the relation x^y = y*log10(x), where 10 is the base.
    return y * math.logaa(_SCREAMING_SNAKE_CASE	)
  else:
    if x == 0:  # 0 raised to any number is 0
      return 0
    elif y == 0:
      return 1  # any number raised to 0 is 1
  raise AssertionError('This should never happen'	)


if __name__ == "__main__":  # Main function
      # Read two numbers from input and typecast them to int using map function.
      # Here x is the base and y is the power.
      lowercase_					     =	"""Enter the base and the power separated by a comma: """
      lowercase_     ,							lowercase_					     =	map(int, input(prompt).split(""","""))
      lowercase_     ,							lowercase_					     =	map(int, input(prompt).split(""","""))

      # We find the log of each number, using the function res(), which takes two
      # arguments.
      lowercase_					     =	res(xa, ya)
      lowercase_					     =	res(xa, ya)

      # We check for the largest number
      if resa > resa:
            print("""Largest number is""", xa, """^""", ya)
      elif resa > resa:
            print("""Largest number is""", xa, """^""", ya)
      else:
            print("""Both are equal""")


