





def 	lowerCamelCase_		(							_UpperCamelCase					)						->		str:






				"""simple docstring"""


				snake_case_		:       str           =    ''''''
				for ch in key:
								if ch == " " or ch not in key_no_dups and ch.isalpha():
												key_no_dups += ch
				return key_no_dups






def 	lowerCamelCase_		(							_UpperCamelCase					)						->		dict[str, str]:






				"""simple docstring"""


				snake_case_		:       Tuple           =    [chr(i + 65					) for i in range(26					)]
				# Remove duplicate characters from key
				snake_case_		:       Optional[Any]           =    remove_duplicates(key.upper()					)
				snake_case_		:       str           =    len(_UpperCamelCase					)
				# First fill cipher with key characters
				snake_case_		:       Any           =    {alphabet[i]: char for i, char in enumerate(_UpperCamelCase					)}
				# Then map remaining characters in alphabet to
				# the alphabet from the beginning
				for i in range(len(_UpperCamelCase					)					,							26					):
								snake_case_		:       str           =    alphabet[i - offset]
								# Ensure we are not mapping letters to letters previously mapped
								while char in key:
												offset -= 1
												snake_case_		:       Union[str, Any]           =    alphabet[i - offset]
								snake_case_		:       Optional[Any]           =    char
				return cipher_alphabet






def 	lowerCamelCase_		(							_UpperCamelCase					,							_UpperCamelCase					)						->		str:






				"""simple docstring"""


				return "".join(cipher_map.get(_UpperCamelCase					,							_UpperCamelCase					) for ch in message.upper()					)






def 	lowerCamelCase_		(							_UpperCamelCase					,							_UpperCamelCase					)						->		str:






				"""simple docstring"""


				snake_case_		:       List[Any]           =    {v: k for k, v in cipher_map.items()}
				return "".join(rev_cipher_map.get(_UpperCamelCase					,							_UpperCamelCase					) for ch in message.upper()					)






def 	lowerCamelCase_		(							)						->		None:






				"""simple docstring"""


				snake_case_		:       str           =    input('''Enter message to encode or decode: '''					).strip()
				snake_case_		:       int           =    input('''Enter keyword: '''					).strip()
				snake_case_		:       Optional[Any]           =    input('''Encipher or decipher? E/D:'''					).strip()[0].lower()
				try:
								snake_case_		:       Optional[int]           =    {'''e''': encipher, '''d''': decipher}[option]
				except KeyError:
								raise KeyError('''invalid input option'''					)
				snake_case_		:       Optional[int]           =    create_cipher_map(_UpperCamelCase					)
				print(func(_UpperCamelCase					,							_UpperCamelCase					)					)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()





from __future__ import annotations

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		2
      lowerCamelCase             =		[]
      while i * i <= n:
            if n % i:
                  i += 1
            else:
                  n //= i
                  factors.append(UpperCAmelCase__			)
      if n > 1:
            factors.append(UpperCAmelCase__			)
      return factors


if __name__ == "__main__":
     import doctest

     doctest.testmod()