



'''simple docstring'''






class 				lowercase			:


 """simple docstring"""


 def __init__(				self				)						->  None:
        _UpperCAmelCase    :		Union[str, Any]     	=					[0, 1]







 def _snake_case					(				self    ,a_				)						->  list:
        if (difference := index - (len(self.sequence				) - 2)) >= 1:
               for _ in range(a_				):
                      self.sequence.append(self.sequence[-1] + self.sequence[-2]				)
        return self.sequence[:index]







def        snake_case_   (	)->						None:





       '''simple docstring'''


       print(
           """Fibonacci Series Using Dynamic Programming\n"""			,  """Enter the index of the Fibonacci number you want to calculate """			,  """in the prompt below. (To exit enter exit or Ctrl-C)\n"""			,  sep=""""""			,  )
       _UpperCAmelCase    :		Dict     	=					Fibonacci()

       while True:
              _UpperCAmelCase    :		str     	=					input(""">> """						)
              if prompt in {"exit", "quit"}:
                     break

              try:
                     _UpperCAmelCase    :		int     	=					int(lowerCAmelCase_						)
              except ValueError:
                     print("""Enter a number or 'exit'"""						)
                     continue

              print(fibonacci.get(lowerCAmelCase_						)						)


if __name__ == "__main__":
   main()







import math
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:int					)							->	list:
						if n <= 0:
												raise ValueError('Only positive integers have prime factors'					)
						__magic_name__					:				Union[str, Any]				=   []
						while n % 2 == 0:
												pf.append(2					)
												__magic_name__					:				Union[str, Any]				=   int(n / 2					)
						for i in range(3   ,    int(math.sqrt(lowercase__					)					) + 1   ,    2					):
												while n % i == 0:
																		pf.append(lowercase__					)
																		__magic_name__					:				List[str]				=   int(n / i					)
						if n > 2:
												pf.append(lowercase__					)
						return pf
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:int					)							->	int:
						if n <= 0:
												raise ValueError('Only positive numbers are accepted'					)
						__magic_name__					:				Union[str, Any]				=   1
						__magic_name__					:				Tuple				=   1
						while n % 2 == 0:
												temp += 1
												__magic_name__					:				Any				=   int(n / 2					)
						div *= temp
						for i in range(3   ,    int(math.sqrt(lowercase__					)					) + 1   ,    2					):
												__magic_name__					:				List[Any]				=   1
												while n % i == 0:
																		temp += 1
																		__magic_name__					:				Any				=   int(n / i					)
												div *= temp
						if n > 1:
												div *= 2
						return div
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:int					)							->	int:
						if n <= 0:
												raise ValueError('Only positive numbers are accepted'					)
						__magic_name__					:				int				=   1
						__magic_name__					:				List[str]				=   1
						while n % 2 == 0:
												temp += 1
												__magic_name__					:				List[Any]				=   int(n / 2					)
						if temp > 1:
												s *= (2**temp - 1) / (2 - 1)
						for i in range(3   ,    int(math.sqrt(lowercase__					)					) + 1   ,    2					):
												__magic_name__					:				int				=   1
												while n % i == 0:
																		temp += 1
																		__magic_name__					:				Optional[Any]				=   int(n / i					)
												if temp > 1:
																		s *= (i**temp - 1) / (i - 1)
						return int(lowercase__					)
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:int					)							->	int:
						__magic_name__					:				Dict				=   n
						for x in set(prime_factors(lowercase__					)					):
												s *= (x - 1) / x
						return int(lowercase__					)


if __name__ == "__main__":
			import doctest

			doctest.testmod()


