



from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize

class 	__lowerCAmelCase							(UpperCamelCase__  ):


					'''simple docstring'''


					a__        =     1
					a__        =     2
					a__        =     3







					def __repr__(      self   ):




										"""simple docstring"""





										return F'''{self.__class__.__name__}.{self.name}'''



def      A      (			_A,     _A,     _A							):




					"""simple docstring"""
					snake_case_						:List[Any]								=						point
					return degrees(atana(y - miny,     x - minx							)							)
def      A      (			_A,     _A,     _A							):




					"""simple docstring"""
					snake_case_						:Optional[int]								=						starting
					snake_case_						:List[Any]								=						via
					snake_case_						:List[str]								=						target
					snake_case_						:Dict								=						degrees(atana(ya - ya,     xa - xa							)							)
					via_angle %= 360
					snake_case_						:Any								=						degrees(atana(ya - ya,     xa - xa							)							)
					target_angle %= 360
					# t-
					#  \ \
					#   \ v
					#    \|
					#     s
					# via_angle is always lower than target_angle, if direction is left.
					# If they are same, it means they are on a same line of convex hull.
					if target_angle > via_angle:
										return Direction.left
					elif target_angle == via_angle:
										return Direction.straight
					else:
										return Direction.right
def      A      (			_A							):




					"""simple docstring"""





					if len(__a							) <= 2:
										# There is no convex hull
										raise ValueError("graham_scan: argument must contain more than 3 points."							)
					if len(__a							) == 3:
										return points
					# find the lowest and the most left point
					snake_case_						:Optional[int]								=						0
					snake_case_						:List[str]								=						maxsize, maxsize
					for i, point in enumerate(__a							):
										snake_case_						:Optional[Any]								=						point[0]
										snake_case_						:Optional[int]								=						point[1]
										if y < miny:
															snake_case_						:Union[str, Any]								=						y
															snake_case_						:Union[str, Any]								=						x
															snake_case_						:int								=						i
										if y == miny and x < minx:
															snake_case_						:Tuple								=						x
															snake_case_						:str								=						i

    # remove the lowest and the most left point from points for preparing for sort
					points.pop(__a							)

					snake_case_						:int								=						sorted(__a,     key=lambda _A							: angle_comparer(__a,     __a,     __a							)							)
					# This insert actually costs complexity,
					# and you should instead add (minx, miny) into stack later.
					# I'm using insert just for easy understanding.
					sorted_points.insert(0,     (minx, miny)							)

					snake_case_						:deque[tuple[int, int]]								=						deque()
					stack.append(sorted_points[0]							)
					stack.append(sorted_points[1]							)
					stack.append(sorted_points[2]							)
					# In any ways, the first 3 points line are towards left.
					# Because we sort them the angle from minx, miny.
					snake_case_						:List[Any]								=						Direction.left

					for i in range(3,     len(__a							)							):
										while True:
															snake_case_						:List[str]								=						stack[-2]
															snake_case_						:List[str]								=						stack[-1]
															snake_case_						:str								=						sorted_points[i]
															snake_case_						:int								=						check_direction(__a,     __a,     __a							)

															if next_direction == Direction.left:
																				snake_case_						:Tuple								=						Direction.left
																				break
															if next_direction == Direction.straight:
																				if current_direction == Direction.left:
																									# We keep current_direction as left.
																									# Because if the straight line keeps as straight,
																									# we want to know if this straight line is towards left.
																									break
																				elif current_direction == Direction.right:
																									# If the straight line is towards right,
																									# every previous points on those straigh line is not convex hull.
																									stack.pop()
															if next_direction == Direction.right:
																				stack.pop()
										stack.append(sorted_points[i]							)
					return list(__a							)






"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if n == 0:
										return 1

					elif n % 2 == 1:
										return binary_exponentiation(_A,     n - 1							) * a

					else:
										snake_case_						:Optional[int]								=						binary_exponentiation(_A,     n / 2							)
										return b * b


if __name__ == "__main__":
				try:
								__UpperCAmelCase      :      str   					=					int(input('Enter Base : ').strip())
								__UpperCAmelCase      :      Any   					=					int(input('Enter Power : ').strip())
				except ValueError:
								print('Invalid literal for integer')

				__UpperCAmelCase      :      Optional[int]   					=					binary_exponentiation(BASE, POWER)
				print(F'''{BASE}^({POWER}) : {RESULT}''')

