





'''simple docstring'''






from typing import Literal

__UpperCamelCase      :   str								=     '''ABCDEFGHIJKLMNOPQRSTUVWXYZ'''





def      lowercase  (  lowerCAmelCase :						str   , lowerCAmelCase :						str   , lowerCAmelCase :						Literal["encrypt", "decrypt"]):



				"""simple docstring"""


				_A :				str				=  LETTERS if mode == '''decrypt''' else key
				_A :				int				=  key if mode == '''decrypt''' else LETTERS
				_A :				Dict				=  ''''''
				# loop through each symbol in the message
				for symbol in message:
								if symbol.upper() in chars_a:
												# encrypt/decrypt the symbol
												_A :				Any				=  chars_a.find(symbol.upper())
												if symbol.isupper():
																translated += chars_b[sym_index].upper()
												else:
																translated += chars_b[sym_index].lower()
								else:
												# symbol is not in LETTERS, just add it
												translated += symbol
				return translated





def      lowercase  (  lowerCAmelCase :						str   , lowerCAmelCase :						str):



				"""simple docstring"""


				return translate_message(lowerCAmelCase   , lowerCAmelCase   , '''encrypt''')





def      lowercase  (  lowerCAmelCase :						str   , lowerCAmelCase :						str):



				"""simple docstring"""


				return translate_message(lowerCAmelCase   , lowerCAmelCase   , '''decrypt''')





def      lowercase  (  ):



				"""simple docstring"""


				_A :				str				=  '''Hello World'''
				_A :				Optional[Any]				=  '''QWERTYUIOPASDFGHJKLZXCVBNM'''
				_A :				Dict				=  '''decrypt'''  # set to 'encrypt' or 'decrypt'

				if mode == "encrypt":
								_A :				int				=  encrypt_message(lowerCAmelCase   , lowerCAmelCase)
				elif mode == "decrypt":
								_A :				str				=  decrypt_message(lowerCAmelCase   , lowerCAmelCase)
				print(f"""Using the key {key}, the {mode}ed message is: {translated}""")


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()







'''simple docstring'''






import sys

sys.set_int_max_str_digits(0)  # type: ignore





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				List[Any]				=  [0] * 11
				_A :				Optional[Any]				=  [0] * 11

				# mark last 9 numbers
				for _ in range(9):
								_A :				Dict				=  1
								_A :				Optional[int]				=  number // 10
				# flag
				_A :				str				=  True

				# check last 9 numbers for pandigitality

				for x in range(9):
								if not check_last[x + 1]:
												_A :				Dict				=  False
				if not f:
								return f

				# mark first 9 numbers
				_A :				str				=  int(str(lowerCAmelCase)[:9])

				for _ in range(9):
								_A :				Tuple				=  1
								_A :				Union[str, Any]				=  number // 10

				# check first 9 numbers for pandigitality

				for x in range(9):
								if not check_front[x + 1]:
												_A :				Union[str, Any]				=  False
				return f





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				Tuple				=  [0] * 11

				# mark last 9 numbers
				for _ in range(9):
								_A :				int				=  1
								_A :				Optional[int]				=  number // 10
				# flag
				_A :				List[str]				=  True

				# check last 9 numbers for pandigitality

				for x in range(9):
								if not check_last[x + 1]:
												_A :				Any				=  False
				return f





def      lowercase  (  ):



				"""simple docstring"""


				_A :				Union[str, Any]				=  1
				_A :				Tuple				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers

				_A :				List[str]				=  1
				_A :				str				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers mod 1e9

				# mod m=1e9, done for fast optimisation
				_A :				Any				=  [0] * 100_0000
				_A :				List[Any]				=  10_0000_0000

				for x in range(100_0000):
								_A :				Dict				=  (aa + ba) % m
								_A :				str				=  ba % m
								_A :				Union[str, Any]				=  ca % m
								if checka(lowerCAmelCase):
												_A :				List[str]				=  1

				for x in range(100_0000):
								_A :				str				=  a + b
								_A :				List[str]				=  b
								_A :				int				=  c
								# perform check only if in tocheck
								if tocheck[x + 3] and check(lowerCAmelCase):
												return x + 3  # first 2 already done
				return -1


if __name__ == "__main__":
	print(f'{solution() = }')
