"""simple docstring"""







import math


def 					a__ (						UpperCAmelCase__    :     int     )->		bool:

						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(UpperCAmelCase__     ) + 1     )						,     6     ):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


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


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


"""simple docstring"""







class      _lowercase						:

				def __init__(       self    :      Tuple    ,      _lowercase    :      int       ):


										'''simple docstring'''
										UpperCAmelCase__   		=						data
										UpperCAmelCase__   		=						None
										UpperCAmelCase__   		=						None


def 					a__ (						UpperCAmelCase__    :     BinaryTreeNode | None						,     UpperCAmelCase__    :     int     )->		BinaryTreeNode | None:
						if node is None:
												UpperCAmelCase__   		=						BinaryTreeNode(UpperCAmelCase__     )
												return node

						# binary search tree is not empty,
						# so we will insert it into the tree
						# if new_value is less than value of data in node,
						#  add it to left subtree and proceed recursively
						if new_value < node.data:
												UpperCAmelCase__   		=						insert(node.left_child						,     UpperCAmelCase__     )
						else:
												# if new_value is greater than value of data in node,
												#  add it to right subtree and proceed recursively
												UpperCAmelCase__   		=						insert(node.right_child						,     UpperCAmelCase__     )
						return node


def 					a__ (						UpperCAmelCase__    :     None | BinaryTreeNode     )->		list[int]:  # if node is None,return
						if node:
												UpperCAmelCase__   		=						inorder(node.left_child     )
												UpperCAmelCase__   		=						[*inorder_array, node.data]
												UpperCAmelCase__   		=						inorder_array + inorder(node.right_child     )
						else:
												UpperCAmelCase__   		=						[]
						return inorder_array


def 					a__ (						)->		BinaryTreeNode | None:
						UpperCAmelCase__   		=						insert(UpperCAmelCase__						,     1_5     )
						insert(UpperCAmelCase__						,     1_0     )
						insert(UpperCAmelCase__						,     2_5     )
						insert(UpperCAmelCase__						,     6     )
						insert(UpperCAmelCase__						,     1_4     )
						insert(UpperCAmelCase__						,     2_0     )
						insert(UpperCAmelCase__						,     6_0     )
						return root


def 					a__ (						)->		None:
						# main function
						UpperCAmelCase__   		=						make_tree()
						print("""Printing values of binary search tree in Inorder Traversal."""     )
						inorder(UpperCAmelCase__     )


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()

