
"""simple docstring"""
lowercase		:    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      lowerCamelCase_     (						lowerCamelCase_			)  ->      list[tuple[str, str]]:


					'''simple docstring'''
					return [alphabet[char] for char in key.upper()]


def      lowerCamelCase_     (						lowerCamelCase_						,					lowerCamelCase_			)  ->      str:


					'''simple docstring'''
					__a:    Tuple		     =       ''''''
					__a:    Optional[Any]		     =       0
					__a:    Optional[int]		     =       generate_table(UpperCamelCase__			)
					for char in words.upper():
										cipher += get_opponent(table[count]						,					UpperCamelCase__			)
										__a:    Any		     =       (count + 1) % len(UpperCamelCase__			)
					return cipher


def      lowerCamelCase_     (						lowerCamelCase_						,					lowerCamelCase_			)  ->      str:


					'''simple docstring'''
					return encrypt(UpperCamelCase__						,					UpperCamelCase__			)


def      lowerCamelCase_     (						lowerCamelCase_						,					lowerCamelCase_			)  ->      tuple[int, int]:


					'''simple docstring'''
					__a:    Dict		     =       0 if char in table[0] else 1
					__a:    List[Any]		     =       table[row].index(UpperCamelCase__			)
					return row, col


def      lowerCamelCase_     (						lowerCamelCase_						,					lowerCamelCase_			)  ->      str:


					'''simple docstring'''
					__a:    List[str]		     =       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...
			lowercase		:    Optional[Any]			=       input('Enter key: ').strip()
			lowercase		:    Optional[Any]			=       input('Enter text to encrypt: ').strip()
			lowercase		:    Dict			=       encrypt(key, text)

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





'''simple docstring'''



import pytest

from datasets.utils.version import Version


@pytest.mark.parametrize(
    '''other, expected_equality'''   ,				[
        (Version('''1.0.0'''			), True),
        ('''1.0.0''', True),
        (Version('''2.0.0'''			), False),
        ('''2.0.0''', False),
        ('''1''', False),
        ('''a''', False),
        (1, False),
        (None, False),
    ]   ,				)
def 							__UpperCAmelCase				(				UpperCamelCase__				:Optional[int]   ,				UpperCamelCase__				:int			)		->						List[str]:
				snake_case__      :   Optional[int]      =    Version('''1.0.0'''			)
				assert (version == other) is expected_equality
				assert (version != other) is not expected_equality
				assert (hash(UpperCamelCase__			) == hash(UpperCamelCase__			)) is expected_equality




