


'''simple docstring'''



import math






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       str						,				_SCREAMING_SNAKE_CASE				:       List[str]       ):
					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     :						Union[str, Any]	=     'Enter the base and the power separated by a comma: '
	__lowercase	,				__lowercase     :						str	=     map(int, input(prompt).split(','))
	__lowercase	,				__lowercase     :						List[str]	=     map(int, input(prompt).split(','))

	# We find the log of each number, using the function res(), which takes two
	# arguments.
	__lowercase     :						Optional[int]	=     res(xa, ya)
	__lowercase     :						Dict	=     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 __future__ import annotations

from dataclasses import dataclass





@dataclass
class 							__UpperCamelCase    :
	A_           =   42
	A_           =   None
	A_           =   None






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE				:       TreeNode | None       ):

					# Validation
					def is_valid_tree(_SCREAMING_SNAKE_CASE				:       TreeNode | None       ) -> bool:
										if node is None:
															return True

										if not isinstance(_SCREAMING_SNAKE_CASE						,				_SCREAMING_SNAKE_CASE       ):
															return False

										try:
															float(node.data       )
										except (TypeError, ValueError):
															return False

										return is_valid_tree(node.left       ) and is_valid_tree(node.right       )

					if not is_valid_tree(_SCREAMING_SNAKE_CASE       ):
										raise ValueError(
										    'Each node should be type of TreeNode and data should be float.'       )

					def is_binary_search_tree_recursive_check(
					    _SCREAMING_SNAKE_CASE				:       TreeNode | None						,				_SCREAMING_SNAKE_CASE				:       float						,				_SCREAMING_SNAKE_CASE				:       float       ) -> bool:

										if node is None:
															return True

										return (
										    left_bound < node.data < right_bound
										    and is_binary_search_tree_recursive_check(node.left						,				_SCREAMING_SNAKE_CASE						,				node.data       )
										    and is_binary_search_tree_recursive_check(
										        node.right						,				node.data						,				_SCREAMING_SNAKE_CASE       )
										)

					return is_binary_search_tree_recursive_check(_SCREAMING_SNAKE_CASE						,				-float('inf'       )						,				float('inf'       )       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()



