


import math







def     __magic_name__  (      lowerCAmelCase_):
	'''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     __magic_name__  (      lowerCAmelCase_ = 1000      ,					lowerCAmelCase_ = 1000):
	'''simple docstring'''


	lowerCamelCase_			:							Union[str, Any]      =       [0, 0, 0]  # length, a, b
	for a in range((a_limit * -1) + 1      ,					A_):
		for b in range(2      ,					A_):
			if is_prime(A_):
				lowerCamelCase_			:							str      =       0
				lowerCamelCase_			:							int      =       0
				while is_prime((n**2) + (a * n) + b):
					count += 1
					n += 1
				if count > longest[0]:
					lowerCamelCase_			:							Union[str, Any]      =       [count, a, b]
	lowerCamelCase_			:							Tuple      =       longest[1] * longest[2]
	return ans


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





from __future__ import annotations





class    lowerCAmelCase__				:






						"""simple docstring"""




						def __init__(   self				,							a_     ):
							lowerCamelCase_			:							List[str]      =       value
							lowerCamelCase_			:							Node | None      =       None
							lowerCamelCase_			:							Node | None      =       None





class    lowerCAmelCase__				:






						"""simple docstring"""
						__UpperCAmelCase   :		int




						def __init__(   self     ):
							lowerCamelCase_			:							str      =       0




						def 					_UpperCamelCase			(   self				,							a_				,							a_     ):
							if node is None:
								return

							if path_sum == self.target:
								self.paths += 1

							if node.left:
								self.depth_first_search(node.left				,							path_sum + node.left.value     )
							if node.right:
								self.depth_first_search(node.right				,							path_sum + node.right.value     )




						def 					_UpperCamelCase			(   self				,							a_				,							a_ = None     ):
							if node is None:
								return 0
							if target is not None:
								lowerCamelCase_			:							List[str]      =       target

							self.depth_first_search(a_				,							node.value     )
							self.path_sum(node.left     )
							self.path_sum(node.right     )

							return self.paths


if __name__ == "__main__":
							import doctest

							doctest.testmod()

