

"""simple docstring"""




from __future__ import annotations

from abc import abstractmethod
from collections.abc import Iterable
from typing import Generic, Protocol, TypeVar





class 				lowerCamelCase  (A__     ):

			@abstractmethod
			def __lt__(   self			:  Tuple      ,			__UpperCAmelCase			:  List[str]    )				->      bool:
						pass

			@abstractmethod
			def __gt__(   self			:  List[Any]      ,			__UpperCAmelCase			:  str    )				->      bool:
						pass





			@abstractmethod
			def __eq__(   self			:  Tuple      ,			__UpperCAmelCase			:  Optional[Any]    )				->      bool:
						pass
A_							:     int     =	TypeVar("T", bound=Comparable)





class 				lowerCamelCase  (Generic[T]     ):

			def __init__(   self			:  str    )				->      None:
						SCREAMING_SNAKE_CASE__									= []
						SCREAMING_SNAKE_CASE__									= 0

			def __repr__(   self			:  Any    )				->      str:
						return str(self.h    )

			def    SCREAMING_SNAKE_CASE			(   self			:  List[Any]      ,			__UpperCAmelCase			:  Dict    )				->      int | None:
						if child_idx > 0:
									return (child_idx - 1) // 2
						return None

			def    SCREAMING_SNAKE_CASE			(   self			:  Optional[int]      ,			__UpperCAmelCase			:  Dict    )				->      int | None:
						SCREAMING_SNAKE_CASE__									= 2 * parent_idx + 1
						if left_child_index < self.heap_size:
									return left_child_index
						return None

			def    SCREAMING_SNAKE_CASE			(   self			:  int      ,			__UpperCAmelCase			:  List[str]    )				->      int | None:
						SCREAMING_SNAKE_CASE__									= 2 * parent_idx + 2
						if right_child_index < self.heap_size:
									return right_child_index
						return None

			def    SCREAMING_SNAKE_CASE			(   self			:  str      ,			__UpperCAmelCase			:  Any    )				->      None:
						if index < self.heap_size:
									SCREAMING_SNAKE_CASE__									= index
									SCREAMING_SNAKE_CASE__									= self.left_child_idx(snake_case_    )
									SCREAMING_SNAKE_CASE__									= self.right_child_idx(snake_case_    )
									# check which child is larger than its parent
									if left_child is not None and self.h[left_child] > self.h[violation]:
												SCREAMING_SNAKE_CASE__									= left_child
									if right_child is not None and self.h[right_child] > self.h[violation]:
												SCREAMING_SNAKE_CASE__									= right_child
									# if violation indeed exists
									if violation != index:
												# swap to fix the violation
												SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__									= self.h[index], self.h[violation]
												# fix the subsequent violation recursively if any
												self.max_heapify(snake_case_    )

			def    SCREAMING_SNAKE_CASE			(   self			:  Union[str, Any]      ,			__UpperCAmelCase			:  Union[str, Any]    )				->      None:
						SCREAMING_SNAKE_CASE__									= list(snake_case_    )
						SCREAMING_SNAKE_CASE__									= len(self.h    )
						if self.heap_size > 1:
									# max_heapify from right to left but exclude leaves (last level)
									for i in range(self.heap_size // 2 - 1      ,			-1      ,			-1    ):
												self.max_heapify(snake_case_    )

			def    SCREAMING_SNAKE_CASE			(   self			:  int    )				->      T:
						if self.heap_size >= 2:
									SCREAMING_SNAKE_CASE__									= self.h[0]
									SCREAMING_SNAKE_CASE__									= self.h.pop(-1    )
									self.heap_size -= 1
									self.max_heapify(0    )
									return me
						elif self.heap_size == 1:
									self.heap_size -= 1
									return self.h.pop(-1    )
						else:
									raise Exception("""Empty heap"""    )

			def    SCREAMING_SNAKE_CASE			(   self			:  Any      ,			__UpperCAmelCase			:  Any    )				->      None:
						self.h.append(snake_case_    )
						SCREAMING_SNAKE_CASE__									= (self.heap_size - 1) // 2
						self.heap_size += 1
						while idx >= 0:
									self.max_heapify(snake_case_    )
									SCREAMING_SNAKE_CASE__									= (idx - 1) // 2





			def    SCREAMING_SNAKE_CASE			(   self			:  Dict    )				->      None:
						SCREAMING_SNAKE_CASE__									= self.heap_size
						for j in range(size - 1      ,			0      ,			-1    ):
									SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__									= self.h[j], self.h[0]
									self.heap_size -= 1
									self.max_heapify(0    )
						SCREAMING_SNAKE_CASE__									= size


if __name__ == "__main__":
						import doctest

						# run doc test
						doctest.testmod()

						# demo
						for unsorted in [
						    [0],
						    [2],
						    [3, 5],
						    [5, 3],
						    [5, 5],
						    [0, 0, 0, 0],
						    [1, 1, 1, 1],
						    [2, 2, 3, 5],
						    [0, 2, 2, 3, 5],
						    [2, 5, 3, 0, 2, 3, 0, 3],
						    [6, 1, 2, 7, 9, 3, 4, 5, 10, 8],
						    [103, 9, 1, 7, 11, 15, 25, 201, 209, 107, 5],
						    [-45, -2, -5],
						]:
												print(F'unsorted array: {unsorted}')

												A_							:     List[Any]     =	Heap()
												heap.build_max_heap(unsorted)
												print(F'after build heap: {heap}')

												print(F'max value: {heap.extract_max()}')
												print(F'after max value removed: {heap}')

												heap.insert(100)
												print(F'after new value 100 inserted: {heap}')

												heap.heap_sort()
												print(F'heap-sorted array: {heap}\n')





"""simple docstring"""




import math

def 		A    (       snake_case__      ):




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

def 		A    (       snake_case__ = 10_00						,			snake_case__ = 10_00      ):




			'''simple docstring'''


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


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


