

def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> str:



    '''simple docstring'''






    if not isinstance(_UpperCAmelCase,      _UpperCAmelCase				):
        raise TypeError('plaintext must be a string'				)
    if not isinstance(_UpperCAmelCase,      _UpperCAmelCase				):
        raise TypeError('key must be a string'				)

    if not plaintext:
        raise ValueError('plaintext is empty'				)
    if not key:
        raise ValueError('key is empty'				)

    key += plaintext
    lowerCAmelCase				:			List[str]    			=      plaintext.lower()
    lowerCAmelCase				:			Tuple    			=      key.lower()
    lowerCAmelCase				:			Optional[Any]    			=      0
    lowerCAmelCase				:			List[Any]    			=      0
    lowerCAmelCase				:			List[Any]    			=      ''
    while plaintext_iterator < len(_UpperCAmelCase				):
        if (
            ord(plaintext[plaintext_iterator]				) < 97
            or ord(plaintext[plaintext_iterator]				) > 122
        ):
            ciphertext += plaintext[plaintext_iterator]
            plaintext_iterator += 1
        elif ord(key[key_iterator]				) < 97 or ord(key[key_iterator]				) > 122:
            key_iterator += 1
        else:
            ciphertext += chr(
                (
                    (ord(plaintext[plaintext_iterator]				) - 97 + ord(key[key_iterator]				))
                    - 97
                )
                % 26
                + 97				)
            key_iterator += 1
            plaintext_iterator += 1
    return ciphertext
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> str:



    '''simple docstring'''






    if not isinstance(_UpperCAmelCase,      _UpperCAmelCase				):
        raise TypeError('ciphertext must be a string'				)
    if not isinstance(_UpperCAmelCase,      _UpperCAmelCase				):
        raise TypeError('key must be a string'				)

    if not ciphertext:
        raise ValueError('ciphertext is empty'				)
    if not key:
        raise ValueError('key is empty'				)

    lowerCAmelCase				:			List[Any]    			=      key.lower()
    lowerCAmelCase				:			Any    			=      0
    lowerCAmelCase				:			Optional[Any]    			=      0
    lowerCAmelCase				:			Tuple    			=      ''
    while ciphertext_iterator < len(_UpperCAmelCase				):
        if (
            ord(ciphertext[ciphertext_iterator]				) < 97
            or ord(ciphertext[ciphertext_iterator]				) > 122
        ):
            plaintext += ciphertext[ciphertext_iterator]
        else:
            plaintext += chr(
                (ord(ciphertext[ciphertext_iterator]				) - ord(key[key_iterator]				)) % 26
                + 97				)
            key += chr(
                (ord(ciphertext[ciphertext_iterator]				) - ord(key[key_iterator]				)) % 26
                + 97				)
            key_iterator += 1
        ciphertext_iterator += 1
    return plaintext


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 __A   :     Any      =			int(input('''Type 1 to encrypt or 2 to decrypt:'''))
 if operation == 1:
  __A   :     Tuple      =			input('''Typeplaintext to be encrypted:\n''')
  __A   :     str      =			input('''Type the key:\n''')
  print(encrypt(plaintext, key))
 elif operation == 2:
  __A   :     List[str]      =			input('''Type the ciphertext to be decrypted:\n''')
  __A   :     List[str]      =			input('''Type the key:\n''')
  print(decrypt(ciphertext, key))
 decrypt('''jsqqs avvwo''', '''coffee''')








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A   :     List[Any]      =			{'''configuration_umt5''': ['''UMT5Config''', '''UMT5OnnxConfig''']}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A   :     Tuple      =			[
     '''UMT5EncoderModel''',
     '''UMT5ForConditionalGeneration''',
     '''UMT5ForQuestionAnswering''',
     '''UMT5Model''',
     '''UMT5PreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_umta import UMTaConfig, UMTaOnnxConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_umta import (
      UMTaEncoderModel,
      UMTaForConditionalGeneration,
      UMTaForQuestionAnswering,
      UMTaModel,
      UMTaPreTrainedModel,
  )
else:
 import sys

 __A   :     Any      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





