


import math



def UpperCamelCase_				(				__a			,				__a      )	->   Dict:
      if 0 not in (x, y):
            # We use the relation x^y = y*log10(x), where 10 is the base.
            return y * math.logaa(__a      )
      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.
    UpperCamelCase					:       Tuple			    =     """Enter the base and the power separated by a comma: """
    UpperCamelCase    ,							UpperCamelCase					:       str			    =     map(int, input(prompt).split(""","""))
    UpperCamelCase    ,							UpperCamelCase					:       Tuple			    =     map(int, input(prompt).split(""","""))

    # We find the log of each number, using the function res(), which takes two
    # arguments.
    UpperCamelCase					:       Any			    =     res(xa, ya)
    UpperCamelCase					:       List[str]			    =     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""")






"""simple docstring"""






from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__snake_case				:  Tuple =       {
    'configuration_autoformer': [
        'AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AutoformerConfig',
    ],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__snake_case				:  Optional[Any] =       [
	    'AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'AutoformerForPrediction',
	    'AutoformerModel',
	    'AutoformerPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_autoformer import (
	    AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    AutoformerConfig,
	)

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_autoformer import (
		    AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    AutoformerForPrediction,
		    AutoformerModel,
		    AutoformerPreTrainedModel,
		)

else:
	import sys

	__snake_case				:  Optional[int] =       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)