



"""simple docstring"""






import math
def      A      (			_A							):




					"""simple docstring"""

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5,     int(math.sqrt(_A							) + 1							),     6							):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True
def      A      (			_A = 2_000_000							):




					"""simple docstring"""
					return sum(num for num in range(3,     _A,     2							) if is_prime(_A							)							) + 2 if n > 2 else 0


if __name__ == "__main__":
				print(F'''{solution() = }''')










"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if not isinstance(_A,     _A							):
										raise TypeError("plaintext must be a string"							)
					if not isinstance(_A,     _A							):
										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
					snake_case_						:Optional[int]								=						plaintext.lower()
					snake_case_						:Union[str, Any]								=						key.lower()
					snake_case_						:Any								=						0
					snake_case_						:str								=						0
					snake_case_						:Union[str, Any]								=						""
					while plaintext_iterator < len(_A							):
										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      (			_A,     _A							):




					"""simple docstring"""
					if not isinstance(_A,     _A							):
										raise TypeError("ciphertext must be a string"							)
					if not isinstance(_A,     _A							):
										raise TypeError("key must be a string"							)

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

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

