
'''simple docstring'''



from typing import Literal

UpperCamelCase__					:						Dict											=     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def       lowerCAmelCase_		( SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_  )   ->   Any:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE          = LETTERS if mode == "decrypt" else key
   _SCREAMING_SNAKE_CASE          = key if mode == "decrypt" else LETTERS
   _SCREAMING_SNAKE_CASE          = ""
   # loop through each symbol in the message
   for symbol in message:
      if symbol.upper() in chars_a:
         # encrypt/decrypt the symbol
         _SCREAMING_SNAKE_CASE          = 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       lowerCAmelCase_		( SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_  )   ->   str:




   """simple docstring"""
   return translate_message(__lowerCamelCase			,					__lowerCamelCase			,					"""encrypt"""  )
def       lowerCAmelCase_		( SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_  )   ->   int:




   """simple docstring"""
   return translate_message(__lowerCamelCase			,					__lowerCamelCase			,					"""decrypt"""  )
def       lowerCAmelCase_		( )   ->   Dict:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE          = "Hello World"
   _SCREAMING_SNAKE_CASE          = "QWERTYUIOPASDFGHJKLZXCVBNM"
   _SCREAMING_SNAKE_CASE          = "decrypt"  # set to 'encrypt' or 'decrypt'

   if mode == "encrypt":
      _SCREAMING_SNAKE_CASE          = encrypt_message(__lowerCamelCase			,					__lowerCamelCase  )
   elif mode == "decrypt":
      _SCREAMING_SNAKE_CASE          = decrypt_message(__lowerCamelCase			,					__lowerCamelCase  )
   print(F"Using the key {key}, the {mode}ed message is: {translated}"  )


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()













import sys

sys.set_int_max_str_digits(0)  # type: ignore






def 			lowerCamelCase__	(__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		int  			=							[0] * 11
     _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							[0] * 11

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

     # check last 9 numbers for pandigitality

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

     # mark first 9 numbers
     _SCREAMING_SNAKE_CASE				:		str  			=							int(str(__lowerCamelCase		)[:9]		)

     for _ in range(9		):
          _SCREAMING_SNAKE_CASE				:		str  			=							1
          _SCREAMING_SNAKE_CASE				:		List[Any]  			=							number // 10

     # check first 9 numbers for pandigitality

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






def 			lowerCamelCase__	(__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		List[str]  			=							[0] * 11

     # mark last 9 numbers
     for _ in range(9		):
          _SCREAMING_SNAKE_CASE				:		Dict  			=							1
          _SCREAMING_SNAKE_CASE				:		List[str]  			=							number // 10
     # flag
     _SCREAMING_SNAKE_CASE				:		List[Any]  			=							True

     # check last 9 numbers for pandigitality

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






def 			lowerCamelCase__	():
     _SCREAMING_SNAKE_CASE				:		Dict  			=							1
     _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							1
     _SCREAMING_SNAKE_CASE				:		List[str]  			=							2
     # temporary Fibonacci numbers

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

     # mod m=1e9, done for fast optimisation
     _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							[0] * 1000000
     _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							1000000000

     for x in range(1000000		):
          _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							(aa + ba) % m
          _SCREAMING_SNAKE_CASE				:		int  			=							ba % m
          _SCREAMING_SNAKE_CASE				:		List[str]  			=							ca % m
          if checka(__lowerCamelCase		):
               _SCREAMING_SNAKE_CASE				:		List[Any]  			=							1

     for x in range(1000000		):
          _SCREAMING_SNAKE_CASE				:		Any  			=							a + b
          _SCREAMING_SNAKE_CASE				:		Dict  			=							b
          _SCREAMING_SNAKE_CASE				:		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() = }")