

'''simple docstring'''




_lowerCAmelCase    			=						{
    "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       ( a )      ->	list[tuple[str, str]]:






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




def 						UpperCamelCase       ( a		,						a )      ->	str:






     '''simple docstring'''
     __magic_name__						   =				''''''
     __magic_name__						   =				0
     __magic_name__						   =				generate_table(a_ )
     for char in words.upper():
          cipher += get_opponent(table[count]		,						a_ )
          __magic_name__						   =				(count + 1) % len(a_ )
     return cipher




def 						UpperCamelCase       ( a		,						a )      ->	str:






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




def 						UpperCamelCase       ( a		,						a )      ->	tuple[int, int]:






     '''simple docstring'''
     __magic_name__						   =				0 if char in table[0] else 1
     __magic_name__						   =				table[row].index(a_ )
     return row, col




def 						UpperCamelCase       ( a		,						a )      ->	str:






     '''simple docstring'''
     __magic_name__   ,  __magic_name__						   =				get_position(a_		,						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    			=						input("Enter key: ").strip()
      _lowerCAmelCase    			=						input("Enter text to encrypt: ").strip()
      _lowerCAmelCase    			=						encrypt(key, text)

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














from dataclasses import dataclass
from typing import Callable, Optional

import datasets




@dataclass
class 							a_ (						datasets.BuilderConfig		):


							'''simple docstring'''






							__a:	Optional[Callable]     =    None
							__a:	Optional[dict]     =    None
							__a:	Optional[datasets.Features]     =    None

							def      _lowercase       (		self   )					->					Optional[int]:
														'''simple docstring'''

														assert self.generator is not None, "generator must be specified"

														if self.gen_kwargs is None:
																					lowerCAmelCase_										=     {}




class 							a_ (						datasets.GeneratorBasedBuilder		):


							'''simple docstring'''






							__a:	Optional[Any]     =    GeneratorConfig

							def      _lowercase       (		self   )					->					Union[str, Any]:
														'''simple docstring'''

														return datasets.DatasetInfo(features=self.config.features   )

							def      _lowercase       (		self			,			lowercase_   )					->					Dict:
														'''simple docstring'''

														return [datasets.SplitGenerator(name=datasets.Split.TRAIN			,			gen_kwargs=self.config.gen_kwargs   )]






							def      _lowercase       (		self			,			**lowercase_   )					->					Union[str, Any]:
														'''simple docstring'''

														for idx, ex in enumerate(self.config.generator(**lowercase_   )   ):
																					yield idx, ex



