


import os
import string
import sys


lowerCAmelCase	=							1 << 8

lowerCAmelCase	=							{
    'tab': ord('\t'),
    'newline': ord('\r'),
    'esc': 27,
    'up': 65 + ARROW_KEY_FLAG,
    'down': 66 + ARROW_KEY_FLAG,
    'right': 67 + ARROW_KEY_FLAG,
    'left': 68 + ARROW_KEY_FLAG,
    'mod_int': 91,
    'undefined': sys.maxsize,
    'interrupt': 3,
    'insert': 50,
    'delete': 51,
    'pg_up': 53,
    'pg_down': 54,
}

lowerCAmelCase	=							KEYMAP['up']
lowerCAmelCase	=							KEYMAP['left']

if sys.platform == "win32":
			lowerCAmelCase	=							[]
			lowerCAmelCase	=							{
			    b'\xe0H': KEYMAP['up'] - ARROW_KEY_FLAG,
			    b'\x00H': KEYMAP['up'] - ARROW_KEY_FLAG,
			    b'\xe0P': KEYMAP['down'] - ARROW_KEY_FLAG,
			    b'\x00P': KEYMAP['down'] - ARROW_KEY_FLAG,
			    b'\xe0M': KEYMAP['right'] - ARROW_KEY_FLAG,
			    b'\x00M': KEYMAP['right'] - ARROW_KEY_FLAG,
			    b'\xe0K': KEYMAP['left'] - ARROW_KEY_FLAG,
			    b'\x00K': KEYMAP['left'] - ARROW_KEY_FLAG,
			}

for i in range(10):
			lowerCAmelCase	=							ord(str(i))
def       _a			(				):


		"""simple docstring"""




		if os.name == "nt":
				import msvcrt

				lowercase__						=				'''mbcs'''
				# Flush the keyboard buffer
				while msvcrt.kbhit():
						msvcrt.getch()
				if len(SCREAMING_SNAKE_CASE					) == 0:
						# Read the keystroke
						lowercase__						=				msvcrt.getch()

						# If it is a prefix char, get second part
						if ch in (b"\x00", b"\xe0"):
								lowercase__						=				ch + msvcrt.getch()
								# Translate actual Win chars to bullet char types
								try:
										lowercase__						=				chr(WIN_KEYMAP[cha]					)
										WIN_CH_BUFFER.append(chr(KEYMAP['''mod_int''']					)					)
										WIN_CH_BUFFER.append(SCREAMING_SNAKE_CASE					)
										if ord(SCREAMING_SNAKE_CASE					) in (
										    KEYMAP["insert"] - 1 << 9,
										    KEYMAP["delete"] - 1 << 9,
										    KEYMAP["pg_up"] - 1 << 9,
										    KEYMAP["pg_down"] - 1 << 9,
										):
												WIN_CH_BUFFER.append(chr(1_26					)					)
										lowercase__						=				chr(KEYMAP['''esc''']					)
								except KeyError:
										lowercase__						=				cha[1]
						else:
								lowercase__						=				ch.decode(SCREAMING_SNAKE_CASE					)
				else:
						lowercase__						=				WIN_CH_BUFFER.pop(0					)
		elif os.name == "posix":
				import termios
				import tty

				lowercase__						=				sys.stdin.fileno()
				lowercase__						=				termios.tcgetattr(SCREAMING_SNAKE_CASE					)
				try:
						tty.setraw(SCREAMING_SNAKE_CASE					)
						lowercase__						=				sys.stdin.read(1					)
				finally:
						termios.tcsetattr(SCREAMING_SNAKE_CASE						,    termios.TCSADRAIN						,    SCREAMING_SNAKE_CASE					)
		return ch
def       _a			(				):


		"""simple docstring"""




		lowercase__						=				get_raw_chars()
		if ord(SCREAMING_SNAKE_CASE					) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
				return char

		elif ord(SCREAMING_SNAKE_CASE					) == KEYMAP["esc"]:
				lowercase__						=				get_raw_chars()
				if ord(SCREAMING_SNAKE_CASE					) == KEYMAP["mod_int"]:
						lowercase__						=				get_raw_chars()
						if ord(SCREAMING_SNAKE_CASE					) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(SCREAMING_SNAKE_CASE					) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
								return chr(ord(SCREAMING_SNAKE_CASE					) + ARROW_KEY_FLAG					)
						else:
								return KEYMAP["undefined"]
				else:
						return get_raw_chars()

		else:
				if char in string.printable:
						return char
				else:
						return KEYMAP["undefined"]






def       _a			(				SCREAMING_SNAKE_CASE						,    SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		return base * power(SCREAMING_SNAKE_CASE						,    (exponent - 1)					) if exponent else 1


if __name__ == "__main__":
			print('Raise base to the power of exponent using recursion...')
			lowerCAmelCase	=							int(input('Enter the base: ').strip())
			lowerCAmelCase	=							int(input('Enter the exponent: ').strip())
			lowerCAmelCase	=							power(base, abs(exponent))
			if exponent < 0:  # power() does not properly deal w/ negative exponents
						lowerCAmelCase	=							1 / result
			print(f"""{base} to the power of {exponent} is {result}""")


