code: def 		snake_case__  (		lowercase       ,							lowercase				):
     if not isinstance(lowercase       ,							lowercase				):
        raise TypeError("plaintext must be a string"				)
     if not isinstance(lowercase       ,							lowercase				):
        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_:       str         =  plaintext.lower()
     lowerCAmelCase_:       int         =  key.lower()
     lowerCAmelCase_:       List[str]         =  0
     lowerCAmelCase_:       List[str]         =  0
     lowerCAmelCase_:       Optional[int]         =  ""
     while plaintext_iterator < len(lowercase				):
        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 		snake_case__  (		lowercase       ,							lowercase				):
     if not isinstance(lowercase       ,							lowercase				):
        raise TypeError("ciphertext must be a string"				)
     if not isinstance(lowercase       ,							lowercase				):
        raise TypeError("key must be a string"				)
  
     if not ciphertext:
        raise ValueError("ciphertext is empty"				)
     if not key:
        raise ValueError("key is empty"				)
  
     lowerCAmelCase_:       Optional[Any]         =  key.lower()
     lowerCAmelCase_:       List[str]         =  0
     lowerCAmelCase_:       List[str]         =  0
     lowerCAmelCase_:       Dict         =  ""
     while ciphertext_iterator < len(lowercase				):
        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     :			List[Any]					    =						int(input("""Type 1 to encrypt or 2 to decrypt:"""))
        if operation == 1:
              a     :			List[Any]					    =						input("""Typeplaintext to be encrypted:\n""")
              a     :			Optional[int]					    =						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[Any]					    =						input("""Type the key:\n""")
              print(decrypt(ciphertext, key))
        decrypt("""jsqqs avvwo""", """coffee""")
style_context: import random
  
  class 				_lowercase						:
  
  
  
  
  
  
      '''simple docstring'''
  
  
  
  
      def __init__(						self					,	lowerCamelCase__					,	lowerCamelCase__   ):
         lowerCAmelCase_:       int         =  x
         lowerCAmelCase_:       List[str]         =  y
  
  
  
  
      def     _a						(						self   ):
         return (self.x**2 + self.y**2) <= 1
  
  
  
  
      @classmethod
      def     _a						(						cls   ):
         return cls(x=random.random()					,	y=random.random()   )
  
  
  
  
  
  def 		snake_case__  (		lowercase				):
     if number_of_simulations < 1:
        raise ValueError("At least one simulation is necessary to estimate PI."				)
  
     lowerCAmelCase_:       List[Any]         =  0
     for _ in range(lowercase				):
        lowerCAmelCase_:       Tuple         =  Point.random_unit_square()
  
        if random_point.is_in_unit_circle():
           number_in_unit_circle += 1
  
     return 4 * number_in_unit_circle / number_of_simulations
  
  
  if __name__ == "__main__":
   # import doctest
  
   # doctest.testmod()
   from math import pi
  
   a     :			Union[str, Any]					    =						"""Please enter the desired number of Monte Carlo simulations: """
   a     :			int					    =						estimate_pi(int(input(prompt).strip()))
   print(f'''An estimate of PI is {my_pi} with an error of {abs(my_pi - pi)}''')