code: 
  
  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''')
  
  
  
  
  
  
style_context: 
  
  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__)
  
  
  
  
  
  