



"""simple docstring"""






from __future__ import annotations

class        __SCREAMING_SNAKE_CASE	:


					'''simple docstring'''





					def __init__(       self							:  Optional[int],  lowerCamelCase							:  int = 0     )->					int:
								lowerCamelCase__		:		Optional[int]			=key



					def 		snake_case       (       self							:  List[Any],  lowerCamelCase							:  str,  lowerCamelCase							:  int     )->					list[str]:
								assert isinstance(lowerCamelCase,  lowerCamelCase     ) and isinstance(lowerCamelCase,  lowerCamelCase     )

								lowerCamelCase__		:		Optional[Any]			=key or self.__key or 1

								# make sure key is an appropriate size
								key %= 255

								return [chr(ord(lowerCamelCase     ) ^ key     ) for ch in content]



					def 		snake_case       (       self							:  str,  lowerCamelCase							:  str,  lowerCamelCase							:  int     )->					list[str]:
								assert isinstance(lowerCamelCase,  lowerCamelCase     ) and isinstance(lowerCamelCase,  lowerCamelCase     )

								lowerCamelCase__		:		Dict			=key or self.__key or 1

								# make sure key is an appropriate size
								key %= 255

								return [chr(ord(lowerCamelCase     ) ^ key     ) for ch in content]



					def 		snake_case       (       self							:  Union[str, Any],  lowerCamelCase							:  str,  lowerCamelCase							:  int = 0     )->					str:
								assert isinstance(lowerCamelCase,  lowerCamelCase     ) and isinstance(lowerCamelCase,  lowerCamelCase     )

								lowerCamelCase__		:		Any			=key or self.__key or 1

								# make sure key can be any size
								while key > 255:
											key -= 255

								# This will be returned
								lowerCamelCase__		:		Dict			=''''''

								for ch in content:
											ans += chr(ord(lowerCamelCase     ) ^ key     )

								return ans



					def 		snake_case       (       self							:  int,  lowerCamelCase							:  str,  lowerCamelCase							:  int = 0     )->					str:
								assert isinstance(lowerCamelCase,  lowerCamelCase     ) and isinstance(lowerCamelCase,  lowerCamelCase     )

								lowerCamelCase__		:		List[Any]			=key or self.__key or 1

								# make sure key can be any size
								while key > 255:
											key -= 255

								# This will be returned
								lowerCamelCase__		:		Tuple			=''''''

								for ch in content:
											ans += chr(ord(lowerCamelCase     ) ^ key     )

								return ans



					def 		snake_case       (       self							:  Optional[int],  lowerCamelCase							:  str,  lowerCamelCase							:  int = 0     )->					bool:
								assert isinstance(lowerCamelCase,  lowerCamelCase     ) and isinstance(lowerCamelCase,  lowerCamelCase     )

								try:
											with open(lowerCamelCase     ) as fin, open('''encrypt.out''',  '''w+'''     ) as fout:
														# actual encrypt-process
														for line in fin:
																	fout.write(self.encrypt_string(lowerCamelCase,  lowerCamelCase     )     )

								except OSError:
											return False

								return True




					def 		snake_case       (       self							:  Optional[Any],  lowerCamelCase							:  str,  lowerCamelCase							:  int     )->					bool:
								assert isinstance(lowerCamelCase,  lowerCamelCase     ) and isinstance(lowerCamelCase,  lowerCamelCase     )

								try:
											with open(lowerCamelCase     ) as fin, open('''decrypt.out''',  '''w+'''     ) as fout:
														# actual encrypt-process
														for line in fin:
																	fout.write(self.decrypt_string(lowerCamelCase,  lowerCamelCase     )     )

								except OSError:
											return False

								return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")









"""simple docstring"""






from functools import lru_cache






def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__		:		Optional[Any]			=2
			lowerCamelCase__		:		Optional[int]			=set()
			while i * i <= n:
						if n % i:
									i += 1
						else:
									n //= i
									factors.add(__lowerCamelCase	)
			if n > 1:
						factors.add(__lowerCamelCase	)
			return factors






@lru_cache
def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			return len(unique_prime_factors(__lowerCamelCase	)	)






def      snake_case__   (		__lowerCamelCase				:    list	):
			"""simple docstring"""
			return len(set(__lowerCamelCase	)	) in (0, 1)






def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__		:		Tuple			=2

			while True:
						# Increment each value of a generated range
						lowerCamelCase__		:		Tuple			=[base + i for i in range(__lowerCamelCase	)]

						# Run elements through out unique_prime_factors function
						# Append our target number to the end.
						lowerCamelCase__		:		Optional[Any]			=[upf_len(__lowerCamelCase	) for x in group]
						checker.append(__lowerCamelCase	)

						# If all numbers in the list are equal, return the group variable.
						if equality(__lowerCamelCase	):
									return group

						# Increment our base variable by 1
						base += 1






def      snake_case__   (		__lowerCamelCase				:    int = 4	):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]			=run(__lowerCamelCase	)
			return results[0] if len(__lowerCamelCase	) else None


if __name__ == "__main__":
		print(solution())




