


from __future__ import annotations

# Define the Gravitational Constant G and the function
A :	Tuple												=     6.6_7_4_3e-1_1  # unit of G : m^3 * kg^-1 * s^-2






def 				UpperCamelCase      (			__magic_name__  :							int					,					__magic_name__  :							int					,					__magic_name__  :							Union[str, Any]					,					__magic_name__  :							str  )     ->						dict[str, float]:
		"""simple docstring"""




		lowercase__      =	mass_a * mass_a

		if (force, mass_a, mass_a, distance).count(0  ) != 1:
				raise ValueError("""One and only one argument must be 0"""  )
		if force < 0:
				raise ValueError("""Gravitational force can not be negative"""  )
		if distance < 0:
				raise ValueError("""Distance can not be negative"""  )
		if mass_a < 0 or mass_a < 0:
				raise ValueError("""Mass can not be negative"""  )
		if force == 0:
				lowercase__      =	GRAVITATIONAL_CONSTANT * product_of_mass / (distance**2)
				return {"force": force}
		elif mass_a == 0:
				lowercase__      =	(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
				return {"mass_1": mass_a}
		elif mass_a == 0:
				lowercase__      =	(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
				return {"mass_2": mass_a}
		elif distance == 0:
				lowercase__      =	(GRAVITATIONAL_CONSTANT * product_of_mass / (force)) ** 0.5
				return {"distance": distance}
		raise ValueError("""One and only one argument must be 0"""  )


# Run doctest
if __name__ == "__main__":
	import doctest

	doctest.testmod()





import math






def 				UpperCamelCase      (			__magic_name__  :							int  )     ->						bool:
		"""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(__magic_name__  ) + 1  )					,					6  ):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True






def 				UpperCamelCase      (			__magic_name__  :							int = 1000					,					__magic_name__  :							int = 1000  )     ->						int:
		"""simple docstring"""




		lowercase__      =	[0, 0, 0]  # length, a, b
		for a in range((a_limit * -1) + 1					,					__magic_name__  ):
				for b in range(2					,					__magic_name__  ):
						if is_prime(__magic_name__  ):
								lowercase__      =	0
								lowercase__      =	0
								while is_prime((n**2) + (a * n) + b  ):
										count += 1
										n += 1
								if count > longest[0]:
										lowercase__      =	[count, a, b]
		lowercase__      =	longest[1] * longest[2]
		return ans


if __name__ == "__main__":
	print(solution(1_0_0_0, 1_0_0_0))

