
class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		Optional[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			[0, 1]



     def 					A__			(	self  :		Optional[Any]					,	__lowerCamelCase  :		int	):



       """simple docstring"""
       if (difference := index - (len(self.sequence	) - 2)) >= 1:
         for _ in range(__lowerCamelCase	):
           self.sequence.append(self.sequence[-1] + self.sequence[-2]	)
       return self.sequence[:index]



def 		a_       (   ):
  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=''''''      ,   )
  lowerCAmelCase__								=			Fibonacci()

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

    try:
      lowerCAmelCase__								=			int(__lowerCAmelCase							)
    except ValueError:
      print('''Enter a number or \'exit\''''							)
      continue

    print(fibonacci.get(__lowerCAmelCase							)							)


if __name__ == "__main__":
      main()







from __future__ import annotations

from collections.abc import Iterator
from typing import Any





class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		int					,	__lowerCamelCase  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			data
       lowerCAmelCase__								=			None



     def __str__(	self  :		int	):



       """simple docstring"""
       return F"""{self.data}"""





class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		Union[str, Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			None
       lowerCAmelCase__								=			None
     def __iter__(	self  :		List[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			self.front
       while node:
         yield node.data
         lowerCAmelCase__								=			node.next
     def __len__(	self  :		int	):



       """simple docstring"""
       return len(tuple(iter(self	)	)	)
     def __str__(	self  :		Optional[int]	):



       """simple docstring"""
       return " <- ".join(str(__lowerCamelCase	) for item in self	)
     def 					A__			(	self  :		Tuple	):



       """simple docstring"""
       return len(self	) == 0
     def 					A__			(	self  :		str					,	__lowerCamelCase  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			Node(__lowerCamelCase	)
       if self.is_empty():
         lowerCAmelCase__								=			lowerCAmelCase__								=			node
       else:
         assert isinstance(self.rear					,	__lowerCamelCase	)
         lowerCAmelCase__								=			node
         lowerCAmelCase__								=			node
     def 					A__			(	self  :		Optional[Any]	):



       """simple docstring"""
       if self.is_empty():
         raise IndexError('''dequeue from empty queue'''	)
       assert isinstance(self.front					,	__lowerCamelCase	)
       lowerCAmelCase__								=			self.front
       lowerCAmelCase__								=			self.front.next
       if self.front is None:
         lowerCAmelCase__								=			None
       return node.data



     def 					A__			(	self  :		Tuple	):



       """simple docstring"""
       lowerCAmelCase__								=			lowerCAmelCase__								=			None


if __name__ == "__main__":
      from doctest import testmod

      testmod()

