



import os
import string
import sys


UpperCAmelCase      :							Any							       =1 << 8

UpperCAmelCase      :							Union[str, Any]							       ={
    """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,
}

UpperCAmelCase      :							Tuple							       =KEYMAP["""up"""]
UpperCAmelCase      :							Any							       =KEYMAP["""left"""]

if sys.platform == "win32":
	UpperCAmelCase      :							Optional[Any]							       =[]
	UpperCAmelCase      :							List[str]							       ={
	    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):
	UpperCAmelCase      :							Any							       =ord(str(i))



def       _lowerCAmelCase			():
					if os.name == "nt":
										import msvcrt

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

															# If it is a prefix char, get second part
															if ch in (b"\x00", b"\xe0"):
																				UpperCamelCase_						     =      ch + msvcrt.getch()
																				# Translate actual Win chars to bullet char types
																				try:
																									UpperCamelCase_						     =      chr(WIN_KEYMAP[cha])
																									WIN_CH_BUFFER.append(chr(KEYMAP["mod_int"]))
																									WIN_CH_BUFFER.append(__UpperCAmelCase)
																									if ord(__UpperCAmelCase) 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))
																									UpperCamelCase_						     =      chr(KEYMAP["esc"])
																				except KeyError:
																									UpperCamelCase_						     =      cha[1]
															else:
																				UpperCamelCase_						     =      ch.decode(__UpperCAmelCase)
										else:
															UpperCamelCase_						     =      WIN_CH_BUFFER.pop(0)
					elif os.name == "posix":
										import termios
										import tty

										UpperCamelCase_						     =      sys.stdin.fileno()
										UpperCamelCase_						     =      termios.tcgetattr(__UpperCAmelCase)
										try:
															tty.setraw(__UpperCAmelCase)
															UpperCamelCase_						     =      sys.stdin.read(1)
										finally:
															termios.tcsetattr(__UpperCAmelCase      ,		termios.TCSADRAIN      ,		__UpperCAmelCase)
					return ch






def       _lowerCAmelCase			():
					UpperCamelCase_						     =      get_raw_chars()
					if ord(__UpperCAmelCase) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
										return char

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

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

"""simple docstring"""






from __future__ import annotations

from math import pi, sqrt



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase )  ->  tuple:

   if inductance <= 0:
      raise ValueError('''Inductance cannot be 0 or negative''' )

   elif capacitance <= 0:
      raise ValueError('''Capacitance cannot be 0 or negative''' )

   else:
      return (
          "Resonant frequency",
          float(1 / (2 * pi * (sqrt(inductance * capacitance ))) ),
      )


if __name__ == "__main__":
       import doctest

       doctest.testmod()
