
import math
def    SCREAMING_SNAKE_CASE__		( lowerCAmelCase_				:			Optional[int]       ,lowerCAmelCase_				:			Optional[Any]							)    ->   Optional[Any]:







							"""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(lowerCAmelCase_							)
							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						       =						map(int, input(prompt).split(','))
							__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')







from __future__ import annotations







def 							A__       (    lowerCamelCase    )	->						bool:
				UpperCamelCase_:				Optional[int]						=    len(lowerCamelCase    )
				# We need to create solution object to save path.
				UpperCamelCase_:				List[str]						=    [[0 for _ in range(lowerCamelCase    )] for _ in range(lowerCamelCase    )]
				UpperCamelCase_:				Dict						=    run_maze(lowerCamelCase  ,     0  ,     0  ,     lowerCamelCase    )
				if solved:
								print("""\n""".join(str(lowerCamelCase    ) for row in solutions    )    )
				else:
								print("""No solution exists!"""    )
				return solved







def 							A__       (    lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase    )	->						bool:
				UpperCamelCase_:				Dict						=    len(lowerCamelCase    )
				# Final check point.
				if i == j == (size - 1):
								UpperCamelCase_:				Union[str, Any]						=    1
								return True

				UpperCamelCase_:				List[str]						=    (not i < 0) and (not j < 0)  # Check lower bounds
				UpperCamelCase_:				List[str]						=    (i < size) and (j < size)  # Check upper bounds

				if lower_flag and upper_flag:
								# check for already visited and block points.
								UpperCamelCase_:				Dict						=    (not solutions[i][j]) and (not maze[i][j])
								if block_flag:
												# check visited
												UpperCamelCase_:				Optional[Any]						=    1

												# check for directions
												if (
												    run_maze(lowerCamelCase  ,     i + 1  ,     lowerCamelCase  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     lowerCamelCase  ,     j + 1  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     i - 1  ,     lowerCamelCase  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     lowerCamelCase  ,     j - 1  ,     lowerCamelCase    )
												):
																return True

												UpperCamelCase_:				Optional[Any]						=    0
												return False
				return False


if __name__ == "__main__":
							import doctest

							doctest.testmod()






