
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)


_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)}")
