




lowercase__							:							List[str]													=     {
    "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 		A_	(							snake_case							:				Tuple	) ->      int:



						'''simple docstring'''

						return [alphabet[char] for char in key.upper()]




def 		A_	(							snake_case							:				int	, snake_case							:				Union[str, Any]	) ->      Dict:



						'''simple docstring'''

						__UpperCamelCase       					=     ""
						__UpperCamelCase       					=     0
						__UpperCamelCase       					=     generate_table(_UpperCamelCase	)
						for char in words.upper():
												cipher += get_opponent(table[count]	, _UpperCamelCase	)
												__UpperCamelCase       					=     (count + 1) % len(_UpperCamelCase	)
						return cipher




def 		A_	(							snake_case							:				Dict	, snake_case							:				Any	) ->      List[Any]:



						'''simple docstring'''

						return encrypt(_UpperCamelCase	, _UpperCamelCase	)




def 		A_	(							snake_case							:				List[Any]	, snake_case							:				Union[str, Any]	) ->      Optional[Any]:



						'''simple docstring'''

						__UpperCamelCase       					=     0 if char in table[0] else 1
						__UpperCamelCase       					=     table[row].index(_UpperCamelCase	)
						return row, col




def 		A_	(							snake_case							:				str	, snake_case							:				Any	) ->      List[Any]:



						'''simple docstring'''

						__UpperCamelCase       					=     get_position(_UpperCamelCase	, 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...
				lowercase__							:							List[str]													=     input("Enter key: ").strip()
				lowercase__							:							Union[str, Any]													=     input("Enter text to encrypt: ").strip()
				lowercase__							:							int													=     encrypt(key, text)

				print(F"Encrypted: {cipher_text}")
				print(F"Decrypted with key: {decrypt(key, cipher_text)}")






def 		A_	(							snake_case							:				Union[str, Any]	, snake_case							:				Tuple	, snake_case							:				Optional[Any]	) ->      Union[str, Any]:



						'''simple docstring'''

						assert b != 0, "This cannot accept modulo that is == 0"
						if n == 0:
												return 1

						if n % 2 == 1:
												return (bin_exp_mod(snake_case	, n - 1	, snake_case	) * a) % b

						__UpperCamelCase       					=     bin_exp_mod(snake_case	, n / 2	, snake_case	)
						return (r * r) % b


if __name__ == "__main__":
				try:
								lowercase__							:							Dict													=     int(input("Enter Base : ").strip())
								lowercase__							:							Dict													=     int(input("Enter Power : ").strip())
								lowercase__							:							Dict													=     int(input("Enter Modulo : ").strip())
				except ValueError:
								print("Invalid literal for integer")

				print(bin_exp_mod(BASE, POWER, MODULO))




