

import builtins
import sys

from ...utils.imports import _is_package_available
from . import cursor, input
from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
from .keymap import KEYMAP


A_       : Dict         =			False
try:
	A_       : List[str]         =			_is_package_available('google.colab')
except ModuleNotFoundError:
	pass



@input.register
class     _a						:


					'''simple docstring'''






					def __init__( self    ,       A__ = None    ,       A__ = []			):
						A__							:    Optional[int]        =		0
						A__							:    Tuple        =		choices
						A__							:    Dict        =		prompt
						if sys.platform == "win32":
							A__							:    int        =		"""*"""
						else:
							A__							:    Optional[int]        =		"""➔ """






					def   __A			( self    ,       A__    ,       A__ = ""			):
						if sys.platform != "win32":
							writeColor(self.choices[index]    ,       32    ,       A__			)
						else:
							forceWrite(self.choices[index]    ,       A__			)






					def   __A			( self    ,       A__			):
						if index == self.position:
							forceWrite(F""" {self.arrow_char} """			)
							self.write_choice(A__			)
						else:
							forceWrite(F"""    {self.choices[index]}"""			)
						reset_cursor()






					def   __A			( self    ,       A__    ,       A__ = 1			):
						A__							:    Tuple        =		self.position
						if direction == Direction.DOWN:
							if self.position + 1 >= len(self.choices			):
								return
							self.position += num_spaces
						else:
							if self.position - 1 < 0:
								return
							self.position -= num_spaces
						clear_line()
						self.print_choice(A__			)
						move_cursor(A__    ,       direction.name			)
						self.print_choice(self.position			)






					@input.mark(KEYMAP["""up"""]			)
					def   __A			( self			):
						self.move_direction(Direction.UP			)






					@input.mark(KEYMAP["""down"""]			)
					def   __A			( self			):
						self.move_direction(Direction.DOWN			)






					@input.mark(KEYMAP["""newline"""]			)
					def   __A			( self			):
						move_cursor(len(self.choices			) - self.position    ,       """DOWN"""			)
						return self.position






					@input.mark(KEYMAP["""interrupt"""]			)
					def   __A			( self			):
						move_cursor(len(self.choices			) - self.position    ,       """DOWN"""			)
						raise KeyboardInterrupt






					@input.mark_multiple(*[KEYMAP[str(A__			)] for number in range(10			)]			)
					def   __A			( self			):
						A__							:    Optional[int]        =		int(chr(self.current_selection			)			)
						A__							:    Optional[Any]        =		index - self.position
						if index == self.position:
							return
						if index < len(self.choices			):
							if self.position > index:
								self.move_direction(Direction.UP    ,       -movement			)
							elif self.position < index:
								self.move_direction(Direction.DOWN    ,       A__			)
							else:
								return
						else:
							return






					def   __A			( self    ,       A__ = 0			):
						if self.prompt:
							linebreak()
							forceWrite(self.prompt    ,       """\n"""			)
							if in_colab:
								forceWrite("""Please input a choice index (starting from 0), and press enter"""    ,       """\n"""			)
							else:
								forceWrite("""Please select a choice using the arrow or number keys, and selecting with enter"""    ,       """\n"""			)
						A__							:    List[Any]        =		default_choice
						for i in range(len(self.choices			)			):
							self.print_choice(A__			)
							forceWrite("""\n"""			)
						move_cursor(len(self.choices			) - self.position    ,       """UP"""			)
						with cursor.hide():
							while True:
								if in_colab:
									try:
										A__							:    str        =		int(builtins.input()			)
									except ValueError:
										A__							:    Union[str, Any]        =		default_choice
								else:
									A__							:    str        =		self.handle_input()
								if choice is not None:
									reset_cursor()
									for _ in range(len(self.choices			) + 1			):
										move_cursor(1    ,       """UP"""			)
										clear_line()
									self.write_choice(A__    ,       """\n"""			)
									return choice






from math import factorial

def 						UpperCamelCase					(lowercase_: int = 20					)     ->      int:
	A__							:    Union[str, Any]        =		2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
	# 2, 3,...
	A__							:    Tuple        =		n // 2

	return int(factorial(lowercase_					) / (factorial(lowercase_					) * factorial(n - k					))					)


if __name__ == "__main__":
	import sys

	if len(sys.argv) == 1:
		print(solution(20))
	else:
		try:
			A_       : List[str]         =			int(sys.argv[1])
			print(solution(n))
		except ValueError:
			print('Invalid entry - please enter a number.')



