code: 
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Any  ,						SCREAMING_SNAKE_CASE__						:			Tuple ):
  
  
  
  
  
  
      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
      UpperCamelCase :List[str]										=     plaintext.lower()
      UpperCamelCase :Tuple										=     key.lower()
      UpperCamelCase :Optional[Any]										=     0
      UpperCamelCase :List[Any]										=     0
      UpperCamelCase :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 						_A     (       SCREAMING_SNAKE_CASE__						:			Any  ,						SCREAMING_SNAKE_CASE__						:			Union[str, Any] ):
  
  
  
  
  
  
      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''' )
  
      UpperCamelCase :List[Any]										=     key.lower()
      UpperCamelCase :Any										=     0
      UpperCamelCase :Optional[Any]										=     0
      UpperCamelCase :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()
   __snake_case							      =						int(input("""Type 1 to encrypt or 2 to decrypt:"""))
   if operation == 1:
    __snake_case							      =						input("""Typeplaintext to be encrypted:\n""")
    __snake_case							      =						input("""Type the key:\n""")
    print(encrypt(plaintext, key))
   elif operation == 2:
    __snake_case							      =						input("""Type the ciphertext to be decrypted:\n""")
    __snake_case							      =						input("""Type the key:\n""")
    print(decrypt(ciphertext, key))
   decrypt("""jsqqs avvwo""", """coffee""")
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int ):
      UpperCamelCase :int										=     {1}
      UpperCamelCase :Optional[int]										=     [1]
      for _ in range(2  ,						depth + 1 ):
          UpperCamelCase :Union[str, Any]										=     [*previous_coefficients, 0]
          UpperCamelCase :List[str]										=     [0, *previous_coefficients]
          UpperCamelCase :List[str]										=     []
          for x, y in zip(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ ):
              coefficients.add(x + y )
              previous_coefficients.append(x + y )
      return coefficients
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			set[int] ):
      UpperCamelCase :Union[str, Any]										=     set()
      for number in unique_coefficients:
          UpperCamelCase :Optional[int]										=     2
          UpperCamelCase :List[Any]										=     number
          while divisor**2 <= copy_number:
              UpperCamelCase :List[Any]										=     0
              while copy_number % divisor == 0:
                  copy_number //= divisor
                  multiplicity += 1
              if multiplicity >= 2:
                  non_squarefrees.add(SCREAMING_SNAKE_CASE__ )
                  break
              divisor += 1
  
      return unique_coefficients.difference(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int = 51 ):
      UpperCamelCase :Any										=     get_pascal_triangle_unique_coefficients(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :str										=     get_squarefrees(SCREAMING_SNAKE_CASE__ )
      return sum(SCREAMING_SNAKE_CASE__ )
  
  
  if __name__ == "__main__":
   print(f'''{solution() = }''')
  
  
  
  
  
  