'''simple docstring'''


import math


def    _lowerCamelCase       ( lowerCamelCase_   :				int  ):



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


def    _lowerCamelCase       ( lowerCamelCase_   :				int = 1000      ,	lowerCamelCase_   :				int = 1000  ):



     """simple docstring"""





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


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







'''simple docstring'''

from hashlib import mda, shaaaa

lowerCAmelCase_			:			Union[str, Any]    	=   (shaaaa, mda)





class 				lowercase    :


   def __init__( self					:						Optional[Any] ,		__lowerCAmelCase					:						int = 8)   ->       None:
         lowercase_     			=   0B0
         lowercase_     			=   size


   def __UpperCAmelCase							( self					:						Dict ,		__lowerCAmelCase					:						str)   ->       None:
         lowercase_     			=   self.hash_(__lowerCAmelCase)
         self.bitarray |= h


   def __UpperCAmelCase							( self					:						Union[str, Any] ,		__lowerCAmelCase					:						str)   ->       bool:
         lowercase_     			=   self.hash_(__lowerCAmelCase)
         return (h & self.bitarray) == h


   def __contains__( self					:						str ,		__lowerCAmelCase					:						str)   ->       bool:
         return self.exists(__lowerCAmelCase)


   def __UpperCAmelCase							( self					:						Union[str, Any] ,		__lowerCAmelCase					:						int)   ->       str:
         lowercase_     			=   bin(__lowerCAmelCase)[2:]
         return res.zfill(self.size)


   @property
   def __UpperCAmelCase							( self					:						Dict)   ->       str:
         return self.format_bin(self.bitarray)


   def __UpperCAmelCase							( self					:						Any ,		__lowerCAmelCase					:						str)   ->       int:
         lowercase_     			=   0B0
         for func in HASH_FUNCTIONS:
               lowercase_     			=   (
                   int.from_bytes(func(value.encode()).digest() ,		"little") % self.size
               )
               res |= 2**position
         return res


   def __UpperCAmelCase							( self					:						Union[str, Any] ,		__lowerCAmelCase					:						str)   ->       str:
         return self.format_bin(self.hash_(__lowerCAmelCase))


   @property
   def __UpperCAmelCase							( self					:						str)   ->       float:
         lowercase_     			=   bin(self.bitarray).count("1")
         return (n_ones / self.size) ** len(__lowerCAmelCase)






