




_lowerCamelCase					:     Union[str, Any]					  =  {
    "A": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
    "B": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
    "C": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
    "D": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
    "E": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
    "F": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
    "G": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
    "H": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
    "I": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
    "J": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
    "K": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
    "L": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
    "M": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
    "N": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
    "O": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
    "P": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
    "Q": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
    "R": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
    "S": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
    "T": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
    "U": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
    "V": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
    "W": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
    "X": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
    "Y": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
    "Z": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
}




def 							_UpperCAmelCase     (UpperCamelCase_       :       str				):
				'''simple docstring'''
				return [alphabet[char] for char in key.upper()]




def 							_UpperCAmelCase     (UpperCamelCase_       :       str					,			UpperCamelCase_       :       str				):
				'''simple docstring'''
				_lowerCAmelCase			:			List[str]        =					""""""
				_lowerCAmelCase			:			Tuple        =					0
				_lowerCAmelCase			:			Union[str, Any]        =					generate_table(UpperCamelCase_				)
				for char in words.upper():
								cipher += get_opponent(table[count]					,			UpperCamelCase_				)
								_lowerCAmelCase			:			Dict        =					(count + 1) % len(UpperCamelCase_				)
				return cipher




def 							_UpperCAmelCase     (UpperCamelCase_       :       str					,			UpperCamelCase_       :       str				):
				'''simple docstring'''
				return encrypt(UpperCamelCase_					,			UpperCamelCase_				)




def 							_UpperCAmelCase     (UpperCamelCase_       :       tuple[str, str]					,			UpperCamelCase_       :       str				):
				'''simple docstring'''
				_lowerCAmelCase			:			Dict        =					0 if char in table[0] else 1
				_lowerCAmelCase			:			Any        =					table[row].index(UpperCamelCase_				)
				return row, col




def 							_UpperCAmelCase     (UpperCamelCase_       :       tuple[str, str]					,			UpperCamelCase_       :       str				):
				'''simple docstring'''
				_lowerCAmelCase    ,			_lowerCAmelCase			:			int        =					get_position(UpperCamelCase_					,			char.upper()				)
				if row == 1:
								return table[0][col]
				else:
								return table[1][col] if row == 0 else char


if __name__ == "__main__":
	import doctest

	doctest.testmod()  # Fist ensure that all our tests are passing...
	_lowerCamelCase					:     Dict					  =  input("Enter key: ").strip()
	_lowerCamelCase					:     List[Any]					  =  input("Enter text to encrypt: ").strip()
	_lowerCamelCase					:     Union[str, Any]					  =  encrypt(key, text)

	print(F'''Encrypted: {cipher_text}''')
	print(F'''Decrypted with key: {decrypt(key, cipher_text)}''')



'''simple docstring'''

import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
   import torch







class 	__lowerCAmelCase    (  unittest.TestCase       ,					__a				):



     def     snake_case_ (self	):
          _UpperCAmelCase					:  Tuple         =    load_tool("""speech-to-text"""	)
          self.tool.setup()



     def     snake_case_ (self	):
          _UpperCAmelCase					:  str         =    self.tool(torch.ones(3_0_0_0	)	)
          self.assertEqual(lowerCAmelCase__						,	""" you"""	)



     def     snake_case_ (self	):
          _UpperCAmelCase					:  Union[str, Any]         =    self.tool(audio=torch.ones(3_0_0_0	)	)
          self.assertEqual(lowerCAmelCase__						,	""" you"""	)


