




import math

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

def 	lowerCAmelCase_	(     lowerCamelCase:				int = 10_00   , lowerCamelCase:				int = 10_00  )    ->	int:


      '''simple docstring'''




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


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







import math
from collections.abc import Generator


def      lowerCamelCase__	(   lowercase ):

  """simple docstring"""






  SCREAMING_SNAKE_CASE				:					Generator		  =			(i for i in range(1  ,   (max_n + 1) ))
  for i in (n for n in numbers if n > 1):
    for j in range(2  ,   lowercase ):
      if (i % j) == 0:
        break
    else:
      yield i


def      lowerCamelCase__	(   lowercase ):

  """simple docstring"""






  SCREAMING_SNAKE_CASE				:					Generator		  =			(i for i in range(1  ,   (max_n + 1) ))
  for i in (n for n in numbers if n > 1):
    # only need to check for factors up to sqrt(i)
    SCREAMING_SNAKE_CASE				:					str		  =			int(math.sqrt(lowercase ) ) + 1
    for j in range(2  ,   lowercase ):
      if (i % j) == 0:
        break
    else:
      yield i


def      lowerCamelCase__	(   lowercase ):

  """simple docstring"""






  SCREAMING_SNAKE_CASE				:					Generator		  =			(i for i in range(1  ,   (max_n + 1)  ,   2 ))
  # It's useless to test even numbers as they will not be prime
  if max_n > 2:
    yield 2  # Because 2 will not be tested, it's necessary to yield it now
  for i in (n for n in numbers if n > 1):
    SCREAMING_SNAKE_CASE				:					Optional[Any]		  =			int(math.sqrt(lowercase ) ) + 1
    for j in range(3  ,   lowercase  ,   2 ):
      # As we removed the even numbers, we don't need them now
      if (i % j) == 0:
        break
    else:
      yield i


def      lowerCamelCase__	(   ):

  """simple docstring"""






  from timeit import timeit

  SCREAMING_SNAKE_CASE				:					Tuple		  =			"from __main__ import slow_primes, primes, fast_primes"
  print(timeit("slow_primes(1_000_000_000_000)"  ,   setup=lowercase  ,   number=1000000 ) )
  print(timeit("primes(1_000_000_000_000)"  ,   setup=lowercase  ,   number=1000000 ) )
  print(timeit("fast_primes(1_000_000_000_000)"  ,   setup=lowercase  ,   number=1000000 ) )


if __name__ == "__main__":
   snake_case			 =						int(input("""Calculate primes up to:\n>> """).strip())
   for ret in primes(number):
      print(ret)
   benchmark()






