



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					if not isinstance(_lowerCAmelCase ,						_lowerCAmelCase):
										raise TypeError("plaintext must be a string")
					if not isinstance(_lowerCAmelCase ,						_lowerCAmelCase):
										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_			= plaintext.lower()
					UpperCamelCase_			= key.lower()
					UpperCamelCase_			= 0
					UpperCamelCase_			= 0
					UpperCamelCase_			= ""
					while plaintext_iterator < len(_lowerCAmelCase):
										if (
										    ord(plaintext[plaintext_iterator]) < 97
										    or ord(plaintext[plaintext_iterator]) > 1_22
										):
															ciphertext += plaintext[plaintext_iterator]
															plaintext_iterator += 1
										elif ord(key[key_iterator]) < 97 or ord(key[key_iterator]) > 1_22:
															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  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					if not isinstance(_lowerCAmelCase ,						_lowerCAmelCase):
										raise TypeError("ciphertext must be a string")
					if not isinstance(_lowerCAmelCase ,						_lowerCAmelCase):
										raise TypeError("key must be a string")

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

					UpperCamelCase_			= key.lower()
					UpperCamelCase_			= 0
					UpperCamelCase_			= 0
					UpperCamelCase_			= ""
					while ciphertext_iterator < len(_lowerCAmelCase):
										if (
										    ord(ciphertext[ciphertext_iterator]) < 97
										    or ord(ciphertext[ciphertext_iterator]) > 1_22
										):
															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()
	UpperCAmelCase :				Dict							=int(input("""Type 1 to encrypt or 2 to decrypt:"""))
	if operation == 1:
		UpperCAmelCase :				Optional[int]							=input("""Typeplaintext to be encrypted:\n""")
		UpperCAmelCase :				Dict							=input("""Type the key:\n""")
		print(encrypt(plaintext, key))
	elif operation == 2:
		UpperCAmelCase :				List[str]							=input("""Type the ciphertext to be decrypted:\n""")
		UpperCAmelCase :				List[str]							=input("""Type the key:\n""")
		print(decrypt(ciphertext, key))
	decrypt("""jsqqs avvwo""", """coffee""")

"""simple docstring"""







import math
def     __UpperCAmelCase							(       UpperCAmelCase_       :							int    )				->     str:

	'''simple docstring'''





	if number == 0:
		__snake_case     :				Any 						=					'Zero'
		return words
	else:
		__snake_case     :				Optional[Any] 						=					math.logaa(UpperCAmelCase_    )
		__snake_case     :				Optional[Any] 						=					digits + 1
		__snake_case     :				List[str] 						=					{}
		__snake_case     :				List[str] 						=					''
		__snake_case     :				Any 						=					'One'
		__snake_case     :				List[str] 						=					'Two'
		__snake_case     :				Tuple 						=					'Three'
		__snake_case     :				str 						=					'Four'
		__snake_case     :				int 						=					'Five'
		__snake_case     :				Optional[Any] 						=					'Six'
		__snake_case     :				str 						=					'Seven'
		__snake_case     :				Optional[Any] 						=					'Eight'
		__snake_case     :				Tuple 						=					'Nine'

		__snake_case     :				Tuple 						=					{}
		__snake_case     :				Optional[int] 						=					''
		__snake_case     :				str 						=					'Twenty'
		__snake_case     :				List[str] 						=					'Thirty'
		__snake_case     :				str 						=					'Forty'
		__snake_case     :				Union[str, Any] 						=					'Fifty'
		__snake_case     :				str 						=					'Sixty'
		__snake_case     :				Tuple 						=					'Seventy'
		__snake_case     :				Dict 						=					'Eighty'
		__snake_case     :				Optional[Any] 						=					'Ninety'

		__snake_case     :				List[Any] 						=					{}
		__snake_case     :				Optional[Any] 						=					'Ten'
		__snake_case     :				List[str] 						=					'Eleven'
		__snake_case     :				Any 						=					'Twelve'
		__snake_case     :				Tuple 						=					'Thirteen'
		__snake_case     :				Tuple 						=					'Fourteen'
		__snake_case     :				Optional[int] 						=					'Fifteen'
		__snake_case     :				Any 						=					'Sixteen'
		__snake_case     :				int 						=					'Seventeen'
		__snake_case     :				Dict 						=					'Eighteen'
		__snake_case     :				List[Any] 						=					'Nineteen'

		__snake_case     :				List[Any] 						=					{}
		__snake_case     :				List[Any] 						=					'Hundred,'
		__snake_case     :				Union[str, Any] 						=					'Thousand,'
		__snake_case     :				List[Any] 						=					'Lakh,'
		__snake_case     :				List[Any] 						=					'Crore,'

		__snake_case     :				List[Any] 						=					number
		__snake_case     :				List[Any] 						=					''
		__snake_case     :				List[Any] 						=					0
		__snake_case     :				Union[str, Any] 						=					int(UpperCAmelCase_    )
		while counter < digits:
			__snake_case     :				List[str] 						=					temp_num % 10
			if counter % 2 == 0:
				__snake_case     :				Tuple 						=					''
				if counter in placevalue and current != 0:
					__snake_case     :				List[str] 						=					placevalue[counter]
				if counter == 2:
					__snake_case     :				Dict 						=					singles[current] + addition + words
				elif counter == 0:
					if ((temp_num % 1_00) // 10) == 1:
						__snake_case     :				Dict 						=					teens[current] + addition + words
						__snake_case     :				Dict 						=					temp_num // 10
						counter += 1
					else:
						__snake_case     :				Optional[Any] 						=					singles[current] + addition + words

				else:
					__snake_case     :				Any 						=					doubles[current] + addition + words

			else:
				if counter == 1:
					if current == 1:
						__snake_case     :				Dict 						=					teens[number % 10] + words
					else:
						__snake_case     :				Optional[int] 						=					''
						if counter in placevalue:
							__snake_case     :				Dict 						=					placevalue[counter]
						__snake_case     :				Union[str, Any] 						=					doubles[current] + addition + words
				else:
					__snake_case     :				List[Any] 						=					''
					if counter in placevalue:
						if current == 0 and ((temp_num % 1_00) // 10) == 0:
							__snake_case     :				Optional[Any] 						=					''
						else:
							__snake_case     :				Any 						=					placevalue[counter]
					if ((temp_num % 1_00) // 10) == 1:
						__snake_case     :				int 						=					teens[current] + addition + words
						__snake_case     :				Any 						=					temp_num // 10
						counter += 1
					else:
						__snake_case     :				List[str] 						=					singles[current] + addition + words
			counter += 1
			__snake_case     :				str 						=					temp_num // 10
	return words


if __name__ == "__main__":
	import doctest

	doctest.testmod()





