code: 
  
  
  '''simple docstring'''
  
  
  
  from __future__ import annotations
  
  
  
  def     UpperCAmelCase__      (			UpperCAmelCase_					:       str   ,					UpperCAmelCase_					:       dict[str, str]							)  ->	str:
       __lowerCamelCase       , __lowerCamelCase       , __lowerCamelCase     :			Tuple              =	'', '', ''
       __lowerCamelCase     :			Any              =	[]
  
       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]							)  ->	tuple[str, str, str]:
       __lowerCamelCase       , __lowerCamelCase     :			Any              =	'', ''
       __lowerCamelCase     :			Tuple              =	[]
  
       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_							)
                 __lowerCamelCase     :			Optional[Any]              =	''
  
       return result[0], result[1], result[2]
  
  
  
  def     UpperCAmelCase__      (			UpperCAmelCase_					:       str   ,					UpperCAmelCase_					:       str							)  ->	tuple[str, str, dict[str, str], dict[str, str]]:
       # Validate message and alphabet, set to upper and remove spaces
       __lowerCamelCase     :			List[str]              =	alphabet.replace(' '   ,					''							).upper()
       __lowerCamelCase     :			Union[str, Any]              =	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
       __lowerCamelCase     :			int              =	(
           '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',
       )
       __lowerCamelCase     :			str              =	{}
       __lowerCamelCase     :			Dict              =	{}
       for letter, number in zip(UpperCAmelCase_   ,					UpperCAmelCase_							):
            __lowerCamelCase     :			List[Any]              =	number
            __lowerCamelCase     :			List[Any]              =	letter
  
       return message, alphabet, character_to_number, number_to_character
  
  
  
  def     UpperCAmelCase__      (			UpperCAmelCase_					:       str   ,					UpperCAmelCase_					:       str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ."   ,					UpperCAmelCase_					:       int = 5							)  ->	str:
       __lowerCamelCase       , __lowerCamelCase       , __lowerCamelCase       , __lowerCamelCase     :			List[str]              =	__prepare(
           UpperCAmelCase_   ,					UpperCAmelCase_							)
       __lowerCamelCase       , __lowerCamelCase     :			int              =	'', ''
  
       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							)  ->	str:
       __lowerCamelCase       , __lowerCamelCase       , __lowerCamelCase       , __lowerCamelCase     :			List[Any]              =	__prepare(
           UpperCAmelCase_   ,					UpperCAmelCase_							)
       __lowerCamelCase     :			int              =	[]
       __lowerCamelCase     :			Optional[int]              =	''
  
       for i in range(0   ,					len(UpperCAmelCase_							) + 1   ,					UpperCAmelCase_							):
            __lowerCamelCase       , __lowerCamelCase       , __lowerCamelCase     :			List[Any]              =	__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__":
        A__	:      Any				=						"""DEFEND THE EAST WALL OF THE CASTLE."""
        A__	:      Optional[Any]				=						encrypt_message(msg, """EPSDUCVWYM.ZLKXNBTFGORIJHAQ""")
        A__	:      List[str]				=						decrypt_message(encrypted, """EPSDUCVWYM.ZLKXNBTFGORIJHAQ""")
        print(f'''Encrypted: {encrypted}\nDecrypted: {decrypted}''')
  
  
  
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  
  
  def     UpperCAmelCase__      (			UpperCAmelCase_					:       str							)  ->	int:
       __lowerCamelCase     :			Tuple              =	str(UpperCAmelCase_							).strip()
       if not bin_string:
            raise ValueError('Empty string was passed to the function'							)
       __lowerCamelCase     :			Optional[int]              =	bin_string[0] == '-'
       if is_negative:
            __lowerCamelCase     :			List[Any]              =	bin_string[1:]
       if not all(char in '01' for char in bin_string							):
            raise ValueError('Non-binary value was passed to the function'							)
       __lowerCamelCase     :			Optional[int]              =	0
       for char in bin_string:
            __lowerCamelCase     :			str              =	2 * decimal_number + int(UpperCAmelCase_							)
       return -decimal_number if is_negative else decimal_number
  
  
  if __name__ == "__main__":
        from doctest import testmod
  
        testmod()
  
  
  
  
  
  
  