


class 							A					:
					'''simple docstring'''






					def __init__(self					:		Any	)		->     Optional[int]:




							"""simple docstring"""


							lowercase__      =	[0]
							lowercase__      =	0

					def 						lowerCamelCase__  (self					:		str   ,      _UpperCAmelCase					:		int	)		->     None:




							"""simple docstring"""


							lowercase__      =	self.__heap[i]
							while i // 2 > 0:
									if self.__heap[i] > self.__heap[i // 2]:
											lowercase__      =	self.__heap[i // 2]
											lowercase__      =	temporary
									i //= 2

					def 						lowerCamelCase__  (self					:		Optional[int]   ,      _UpperCAmelCase					:		int	)		->     None:




							"""simple docstring"""


							self.__heap.append(_UpperCAmelCase	)
							self.__size += 1
							self.__swap_up(self.__size	)

					def 						lowerCamelCase__  (self					:		int   ,      _UpperCAmelCase					:		int	)		->     None:




							"""simple docstring"""


							while self.__size >= 2 * i:
									if 2 * i + 1 > self.__size:
											lowercase__      =	2 * i
									else:
											if self.__heap[2 * i] > self.__heap[2 * i + 1]:
													lowercase__      =	2 * i
											else:
													lowercase__      =	2 * i + 1
									lowercase__      =	self.__heap[i]
									if self.__heap[i] < self.__heap[bigger_child]:
											lowercase__      =	self.__heap[bigger_child]
											lowercase__      =	temporary
									lowercase__      =	bigger_child

					def 						lowerCamelCase__  (self					:		int	)		->     int:




							"""simple docstring"""


							lowercase__      =	self.__heap[1]
							lowercase__      =	self.__heap[self.__size]
							self.__size -= 1
							self.__heap.pop()
							self.__swap_down(1	)
							return max_value

					@property
					def 						lowerCamelCase__  (self					:		Optional[Any]	)		->     Tuple:




							"""simple docstring"""


							return self.__heap[1:]


					def __len__(self					:		str	)		->     List[Any]:




							"""simple docstring"""


							return self.__size


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	# create an instance of BinaryHeap
	A :	Tuple												=     BinaryHeap()
	binary_heap.insert(6)
	binary_heap.insert(1_0)
	binary_heap.insert(1_5)
	binary_heap.insert(1_2)
	# pop root(max-values because it is max heap)
	print(binary_heap.pop())  # 15
	print(binary_heap.pop())  # 12
	# get the list and size after operations
	print(binary_heap.get_list)
	print(len(binary_heap))





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))

