




"""simple docstring"""






import heapq as hq
import math
from collections.abc import Iterator






class lowerCAmelCase__      :






			'''simple docstring'''



			def __init__(    self    , lowercase    ):
							_lowerCamelCase	:     Dict       =       str(id_    )
							_lowerCamelCase	:     str       =       None
							_lowerCamelCase	:     Any       =       None
							_lowerCamelCase	:     List[str]       =       []
							_lowerCamelCase	:     List[Any]       =       {}  # {vertex:distance}
			def __lt__(    self    , lowercase    ):
							return self.key < other.key
			def __repr__(    self    ):
							return self.id
			def    A_       (    self    , lowercase    ):
							self.neighbors.append(lowercase    )






			def    A_       (    self    , lowercase    , lowercase    ):
							_lowerCamelCase	:     str       =       weight







def 	_snake_case     (							lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						):
				graph[a - 1].add_neighbor(graph[b - 1]						)
				graph[b - 1].add_neighbor(graph[a - 1]						)
				# add the edges:
				graph[a - 1].add_edge(graph[b - 1]				,       a__						)
				graph[b - 1].add_edge(graph[a - 1]				,       a__						)







def 	_snake_case     (							lowercase__				,       lowercase__						):
				_lowerCamelCase	:     List[str]       =       []
				for u in graph:
								_lowerCamelCase	:     Tuple       =       math.inf
								_lowerCamelCase	:     Any       =       None
				_lowerCamelCase	:     Dict       =       0
				_lowerCamelCase	:     int       =       graph[:]
				while q:
								_lowerCamelCase	:     str       =       min(a__						)
								q.remove(a__						)
								for v in u.neighbors:
												if (v in q) and (u.edges[v.id] < v.key):
																_lowerCamelCase	:     List[str]       =       u
																_lowerCamelCase	:     List[Any]       =       u.edges[v.id]
				for i in range(1				,       len(a__						)						):
								a.append((int(graph[i].id						) + 1, int(graph[i].pi.id						) + 1)						)
				return a







def 	_snake_case     (							lowercase__				,       lowercase__						):






				for u in graph:
								_lowerCamelCase	:     List[str]       =       math.inf
								_lowerCamelCase	:     str       =       None
				_lowerCamelCase	:     Optional[int]       =       0

				_lowerCamelCase	:     Dict       =       list(a__						)
				hq.heapify(a__						)

				while h:
								_lowerCamelCase	:     Union[str, Any]       =       hq.heappop(a__						)
								for v in u.neighbors:
												if (v in h) and (u.edges[v.id] < v.key):
																_lowerCamelCase	:     int       =       u
																_lowerCamelCase	:     List[Any]       =       u.edges[v.id]
																hq.heapify(a__						)

				for i in range(1				,       len(a__						)						):
								yield (int(graph[i].id						) + 1, int(graph[i].pi.id						) + 1)







def 	_snake_case     (							):
				pass








if __name__ == "__main__":
			import doctest

			doctest.testmod()







"""simple docstring"""


import math


def        UpperCAmelCase      (					a__     ,      a__ ):





						'''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(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.
		__SCREAMING_SNAKE_CASE   =   'Enter the base and the power separated by a comma: '
		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE   =   map(int, input(prompt).split(','))
		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE   =   map(int, input(prompt).split(','))

		# We find the log of each number, using the function res(), which takes two
		# arguments.
		__SCREAMING_SNAKE_CASE   =   res(xa, ya)
		__SCREAMING_SNAKE_CASE   =   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')