


'''simple docstring'''






def 	_A				(lowerCAmelCase__  :str		)   ->  str:




     '''simple docstring'''



     _a			      =							''
     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 	_A				(lowerCAmelCase__  :str		)   ->  dict[str, str]:




     '''simple docstring'''



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






def 	_A				(lowerCAmelCase__  :str				,						lowerCAmelCase__  :dict[str, str]		)   ->  str:




     '''simple docstring'''



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






def 	_A				(lowerCAmelCase__  :str				,						lowerCAmelCase__  :dict[str, str]		)   ->  str:




     '''simple docstring'''



     _a			      =							{v: k for k, v in cipher_map.items()}
     return "".join(rev_cipher_map.get(lowerCAmelCase__				,						lowerCAmelCase__		) for ch in message.upper()		)






def 	_A				()   ->  None:




     '''simple docstring'''



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


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()





'''simple docstring'''






def 	_A				(lowerCAmelCase__  :Union[str, Any]		)   ->  List[str]:




     '''simple docstring'''



     return [
         {
             0: [1, 2],
             1: [0, 2],
             2: [0, 1, 3, 5],
             3: [2, 4],
             4: [3],
             5: [2, 6, 8],
             6: [5, 7],
             7: [6, 8],
             8: [5, 7],
         },
         {
             0: [6],
             1: [9],
             2: [4, 5],
             3: [4],
             4: [2, 3],
             5: [2],
             6: [0, 7],
             7: [6],
             8: [],
             9: [1],
         },
         {
             0: [4],
             1: [6],
             2: [],
             3: [5, 6, 7],
             4: [0, 6],
             5: [3, 8, 9],
             6: [1, 3, 4, 7],
             7: [3, 6, 8, 9],
             8: [5, 7],
             9: [5, 7],
         },
         {
             0: [1, 3],
             1: [0, 2, 4],
             2: [1, 3, 4],
             3: [0, 2, 4],
             4: [1, 2, 3],
         },
     ][index]






def 	_A				(lowerCAmelCase__  :dict[int, list[int]]		)   ->  list[tuple[int, int]]:




     '''simple docstring'''



     _a			      =							0
     _a			      =							len(lowerCAmelCase__		)  # No of vertices in graph
     _a			      =							[0] * n
     _a			      =							[False] * n

     def dfs(lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :str				,						lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :Union[str, Any]		):
          _a			      =							True
          _a			      =							id_
          id_ += 1
          for to in graph[at]:
               if to == parent:
                    pass
               elif not visited[to]:
                    dfs(lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__				,						id_		)
                    _a			      =							min(low[at]				,						low[to]		)
                    if id_ <= low[to]:
                         bridges.append((at, to) if at < to else (to, at)		)
               else:
                    # This edge is a back edge and cannot be a bridge
                    _a			      =							min(low[at]				,						low[to]		)

     _a			      =							[]
     for i in range(lowerCAmelCase__		):
          if not visited[i]:
               dfs(lowerCAmelCase__				,						-1				,						lowerCAmelCase__				,						id_		)
     return bridges


if __name__ == "__main__":
 import doctest

 doctest.testmod()

