

import math





def 			_lowercase    (      __UpperCamelCase     :		List[str] ):

      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 			_lowercase    (      __UpperCamelCase     :		Any = 1000   ,       __UpperCamelCase     :		Dict = 1000 ):
      snake_case__					=   [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 ):
                        snake_case__					=   0
                        snake_case__					=   0
                        while is_prime((n**2) + (a * n) + b ):
                              count += 1
                              n += 1
                        if count > longest[0]:
                              snake_case__					=   [count, a, b]
      snake_case__					=   longest[1] * longest[2]
      return ans


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








import sys





def 			_lowercase    (      __UpperCamelCase     :		int   ,       __UpperCamelCase     :		list[int] ):
      if not numbers:
            return 0
      if target == 0 and target in numbers:
            return 0
      if not isinstance(__UpperCamelCase   ,       (list, tuple) ) or not all(
          isinstance(__UpperCamelCase   ,       __UpperCamelCase ) for number in numbers ):
            raise ValueError("""numbers must be an iterable of integers""" )

      snake_case__					=   snake_case__					=   snake_case__					=   0
      snake_case__					=   sys.maxsize

      while right < len(__UpperCamelCase ):
            curr_sum += numbers[right]
            while curr_sum >= target and left <= right:
                  snake_case__					=   min(__UpperCamelCase   ,       right - left + 1 )
                  curr_sum -= numbers[left]
                  left += 1
            right += 1

      return 0 if min_len == sys.maxsize else min_len






