import math


def SCREAMING_SNAKE_CASE					(  lowercase_:						int					):

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


def SCREAMING_SNAKE_CASE					(  lowercase_:						int = 1000		,    lowercase_:						int = 1000					):
       _UpperCamelCase  :							Any	    =	[0, 0, 0]  # length, a, b
       for a in range((a_limit * -1) + 1		,    lowercase_					):
              for b in range(2		,    lowercase_					):
                     if is_prime(lowercase_					):
                            _UpperCamelCase  :							Tuple	    =	0
                            _UpperCamelCase  :							Union[str, Any]	    =	0
                            while is_prime((n**2) + (a * n) + b					):
                                   count += 1
                                   n += 1
                            if count > longest[0]:
                                   _UpperCamelCase  :							List[str]	    =	[count, a, b]
       _UpperCamelCase  :							Optional[int]	    =	longest[1] * longest[2]
       return ans


if __name__ == "__main__":
 print(solution(10_00, 10_00))











from __future__ import annotations







def   snake_case		(				UpperCAmelCase						:							int,    UpperCAmelCase						:							list[int],    UpperCAmelCase						:							list[int],    UpperCAmelCase						:							int ):

				# Base Case
				if counter == 0 or capacity == 0:
								return 0

				# If weight of the nth item is more than Knapsack of capacity,
				#   then this item cannot be included in the optimal solution,
				# else return the maximum of two cases:
				#   (1) nth item included
				#   (2) not included
				if weights[counter - 1] > capacity:
								return knapsack(UpperCAmelCase,    UpperCAmelCase,    UpperCAmelCase,    counter - 1 )
				else:
								A									=   capacity - weights[counter - 1]
								A									=   values[counter - 1] + knapsack(
								    UpperCAmelCase,    UpperCAmelCase,    UpperCAmelCase,    counter - 1 )
								A									=   knapsack(UpperCAmelCase,    UpperCAmelCase,    UpperCAmelCase,    counter - 1 )
								return max(UpperCAmelCase,    UpperCAmelCase )


if __name__ == "__main__":
					import doctest

					doctest.testmod()





