code: 
  import functools
  from math import sqrt
  from time import time
  
  def    __snake_case       (  __magic_name__		,						*__magic_name__		,						**__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			time()
  				lowercase						    =			func(*__magic_name__		,						**__magic_name__	)
  				lowercase						    =			time()
  				if int(end - start	) > 0:
  								print(F'''{func.__name__} runtime: {(end - start):0.4f} s'''	)
  				else:
  								print(F'''{func.__name__} runtime: {(end - start) * 1000:0.4f} ms'''	)
  				return output
  
  def    __snake_case       (  __magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if n < 0:
  								raise Exception("n is negative"	)
  				if n == 0:
  								return [0]
  				lowercase						    =			[0, 1]
  				for _ in range(n - 1	):
  								fib.append(fib[-1] + fib[-2]	)
  				return fib
  
  def    __snake_case       (  __magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				def fib_recursive_term(__magic_name__	) -> int:
  								if i < 0:
  												raise Exception("n is negative"	)
  								if i < 2:
  												return i
  								return fib_recursive_term(i - 1	) + fib_recursive_term(i - 2	)
  
  				if n < 0:
  								raise Exception("n is negative"	)
  				return [fib_recursive_term(__magic_name__	) for i in range(n + 1	)]
  
  def    __snake_case       (  __magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				@functools.cache
  				def fib_recursive_term(__magic_name__	) -> int:
  								if i < 0:
  												raise Exception("n is negative"	)
  								if i < 2:
  												return i
  								return fib_recursive_term(i - 1	) + fib_recursive_term(i - 2	)
  
  				if n < 0:
  								raise Exception("n is negative"	)
  				return [fib_recursive_term(__magic_name__	) for i in range(n + 1	)]
  
  def    __snake_case       (  __magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if n < 0:
  								raise Exception("n is negative"	)
  				# Cache must be outside recursuive function
  				# other it will reset every time it calls itself.
  				lowercase						    =			{0: 0, 1: 1, 2: 1}  # Prefilled cache
  
  				def rec_fn_memoized(__magic_name__	) -> int:
  								if num in cache:
  												return cache[num]
  
  								lowercase						    =			rec_fn_memoized(num - 1	) + rec_fn_memoized(num - 2	)
  								lowercase						    =			value
  								return value
  
  				return [rec_fn_memoized(__magic_name__	) for i in range(n + 1	)]
  
  def    __snake_case       (  __magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if n < 0:
  								raise Exception("n is negative"	)
  				if n >= 1475:
  								raise Exception("n is too large"	)
  				lowercase						    =			sqrt(5	)
  				lowercase						    =			(1 + sqrt_a) / 2
  				return [round(phi**i / sqrt_a	) for i in range(n + 1	)]
  
  
  if __name__ == "__main__":
  						_snake_case			:       str      =						30
  						time_func(fib_iterative, num)
  						time_func(fib_recursive, num)  # Around 3s runtime
  						time_func(fib_recursive_cached, num)  # Around 0ms runtime
  						time_func(fib_memoization, num)
  						time_func(fib_binet, num)
  
style_context: 
  _snake_case			:       List[Any]      =						{
      "A": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
      "B": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
      "C": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
      "D": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
      "E": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
      "F": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
      "G": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
      "H": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
      "I": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
      "J": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
      "K": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
      "L": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
      "M": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
      "N": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
      "O": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
      "P": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
      "Q": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
      "R": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
      "S": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
      "T": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
      "U": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
      "V": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
      "W": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
      "X": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
      "Y": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
      "Z": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
  }
  
  def    __snake_case       (  __magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				return [alphabet[char] for char in key.upper()]
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			""
  				lowercase						    =			0
  				lowercase						    =			generate_table(__magic_name__	)
  				for char in words.upper():
  								cipher += get_opponent(table[count]		,						__magic_name__	)
  								lowercase						    =			(count + 1) % len(__magic_name__	)
  				return cipher
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				return encrypt(__magic_name__		,						__magic_name__	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			0 if char in table[0] else 1
  				lowercase						    =			table[row].index(__magic_name__	)
  				return row, col
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase    ,  lowercase						    =			get_position(__magic_name__		,						char.upper()	)
  				if row == 1:
  								return table[0][col]
  				else:
  								return table[1][col] if row == 0 else char
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()  # Fist ensure that all our tests are passing...
  						_snake_case			:       List[Any]      =						input("Enter key: ").strip()
  						_snake_case			:       Optional[int]      =						input("Enter text to encrypt: ").strip()
  						_snake_case			:       Optional[Any]      =						encrypt(key, text)
  
  						print(F"Encrypted: {cipher_text}")
  						print(F"Decrypted with key: {decrypt(key, cipher_text)}")
  