






'''simple docstring'''

import math






def 	_UpperCAmelCase    (  a		:	Dict						,			a		:	Any							)			->			Optional[int]:





						"""simple docstring"""
						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.
	A:      str  				=				"Enter the base and the power separated by a comma: "
	A				,		A:      int  				=				map(int, input(prompt).split(","))
	A				,		A:      Tuple  				=				map(int, input(prompt).split(","))

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

class 							__magic_name__     :







	"""simple docstring"""



	def __init__(							self  ,      _lowercase       )						->  Union[str, Any]:
							lowercase_      :   Dict        =			n
							lowercase_      :   Dict        =			[None] * self.n
							lowercase_      :   Tuple        =			0  # index of the first element
							lowercase_      :   List[Any]        =			0
							lowercase_      :   List[Any]        =			0
	def __len__(							self       )						->  int:
							return self.size
	def        lowerCamelCase__		(							self       )						->  bool:
							return self.size == 0
	def        lowerCamelCase__		(							self       )						->  List[Any]:
							return False if self.is_empty() else self.array[self.front]
	def        lowerCamelCase__		(							self  ,      _lowercase       )						->  Any:
							if self.size >= self.n:
													raise Exception('QUEUE IS FULL'       )

							lowercase_      :   Tuple        =			data
							lowercase_      :   List[Any]        =			(self.rear + 1) % self.n
							self.size += 1
							return self







	def        lowerCamelCase__		(							self       )						->  Any:
							if self.size == 0:
													raise Exception('UNDERFLOW'       )

							lowercase_      :   Dict        =			self.array[self.front]
							lowercase_      :   Tuple        =			None
							lowercase_      :   int        =			(self.front + 1) % self.n
							self.size -= 1
							return temp
