


from __future__ import annotations
def 							_UpperCAmelCase    (UpperCamelCase__					:  str    ,							UpperCamelCase__					:  dict[str, str]						):
       _A				:	Tuple       =			"", "", ""
       _A				:	int       =			[]

       for character in message_part:
              tmp.append(character_to_number[character]						)

       for each in tmp:
              one += each[0]
              two += each[1]
              three += each[2]

       return one + two + three
def 							_UpperCAmelCase    (UpperCamelCase__					:  str    ,							UpperCamelCase__					:  dict[str, str]						):
       _A				:	Optional[Any]       =			"", ""
       _A				:	Dict       =			[]

       for character in message_part:
              this_part += character_to_number[character]

       for digit in this_part:
              tmp += digit
              if len(UpperCamelCase__						) == len(UpperCamelCase__						):
                     result.append(UpperCamelCase__						)
                     _A				:	Dict       =			""

       return result[0], result[1], result[2]
def 							_UpperCAmelCase    (UpperCamelCase__					:  str    ,							UpperCamelCase__					:  str						):
       # Validate message and alphabet, set to upper and remove spaces
       _A				:	List[Any]       =			alphabet.replace(" "    ,							""						).upper()
       _A				:	int       =			message.replace(" "    ,							""						).upper()

       # Check length and characters
       if len(UpperCamelCase__						) != 27:
              raise KeyError("Length of alphabet has to be 27."						)
       for each in message:
              if each not in alphabet:
                     raise ValueError("Each message character has to be included in alphabet!"						)

    # Generate dictionares
       _A				:	Tuple       =			(
           "111",
           "112",
           "113",
           "121",
           "122",
           "123",
           "131",
           "132",
           "133",
           "211",
           "212",
           "213",
           "221",
           "222",
           "223",
           "231",
           "232",
           "233",
           "311",
           "312",
           "313",
           "321",
           "322",
           "323",
           "331",
           "332",
           "333",
       )
       _A				:	Union[str, Any]       =			{}
       _A				:	List[Any]       =			{}
       for letter, number in zip(UpperCamelCase__    ,							UpperCamelCase__						):
              _A				:	str       =			number
              _A				:	Optional[int]       =			letter

       return message, alphabet, character_to_number, number_to_character
def 							_UpperCAmelCase    (UpperCamelCase__					:  str    ,							UpperCamelCase__					:  str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."    ,							UpperCamelCase__					:  int = 5						):
       _A				:	Optional[int]       =			__prepare(
           UpperCamelCase__    ,							UpperCamelCase__						)
       _A				:	Union[str, Any]       =			"", ""

       for i in range(0    ,							len(UpperCamelCase__						) + 1    ,							UpperCamelCase__						):
              encrypted_numeric += __encrypt_part(
                  message[i : i + period]    ,							UpperCamelCase__						)

       for i in range(0    ,							len(UpperCamelCase__						)    ,							3						):
              encrypted += number_to_character[encrypted_numeric[i : i + 3]]

       return encrypted
def 							_UpperCAmelCase    (UpperCamelCase__					:  str    ,							UpperCamelCase__					:  str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."    ,							UpperCamelCase__					:  int = 5						):
       _A				:	Any       =			__prepare(
           UpperCamelCase__    ,							UpperCamelCase__						)
       _A				:	Optional[Any]       =			[]
       _A				:	Tuple       =			""

       for i in range(0    ,							len(UpperCamelCase__						) + 1    ,							UpperCamelCase__						):
              _A				:	int       =			__decrypt_part(message[i : i + period]    ,							UpperCamelCase__						)

              for j in range(0    ,							len(UpperCamelCase__						)						):
                     decrypted_numeric.append(a[j] + b[j] + c[j]						)

       for each in decrypted_numeric:
              decrypted += number_to_character[each]

       return decrypted


if __name__ == "__main__":
    lowerCAmelCase__						=			"DEFEND THE EAST WALL OF THE CASTLE."
    lowerCAmelCase__						=			encrypt_message(msg, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
    lowerCAmelCase__						=			decrypt_message(encrypted, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
    print(f"Encrypted: {encrypted}\nDecrypted: {decrypted}")




from itertools import permutations
def 							_UpperCAmelCase    ():
       _A				:	List[Any]       =			list(map("".join    ,							permutations("0123456789"						)						)						)
       return result[999999]


if __name__ == "__main__":
    print(solution())
