





import math







def  lowerCAmelCase__(		lowercase    :      int			)	->      bool:

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


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








_UpperCamelCase    =	[chr(i) for i in range(32, 126)]
_UpperCamelCase    =	list(range(len(alphabets)))
_UpperCamelCase    =	list(range(len(alphabets)))
_UpperCamelCase    =	list(range(len(alphabets)))
_UpperCamelCase    =	list(reversed(range(len(alphabets))))
_UpperCamelCase    =	[]
_UpperCamelCase    =	_UpperCamelCase    =	_UpperCamelCase    =	0







def  lowerCAmelCase__(		)	->      int:
  global gear_one_pos
  global gear_two_pos
  global gear_three_pos
  __snake_case				:			int            =    gear_one[0]
  gear_one.append(lowercase			)
  del gear_one[0]
  gear_one_pos += 1
  if gear_one_pos % int(len(lowercase			)			) == 0:
    __snake_case				:			List[str]            =    gear_two[0]
    gear_two.append(lowercase			)
    del gear_two[0]
    gear_two_pos += 1
    if gear_two_pos % int(len(lowercase			)			) == 0:
      __snake_case				:			Any            =    gear_three[0]
      gear_three.append(lowercase			)
      del gear_three[0]
      gear_three_pos += 1







def  lowerCAmelCase__(		lowercase    :      Tuple			)	->      Union[str, Any]:
  __snake_case				:			Union[str, Any]            =    alphabets.index(lowercase			)
  __snake_case				:			Tuple            =    gear_one[target]
  __snake_case				:			Union[str, Any]            =    gear_two[target]
  __snake_case				:			int            =    gear_three[target]
  __snake_case				:			Optional[int]            =    reflector[target]
  __snake_case				:			Union[str, Any]            =    gear_three.index(lowercase			)
  __snake_case				:			Optional[Any]            =    gear_two.index(lowercase			)
  __snake_case				:			int            =    gear_one.index(lowercase			)
  code.append(alphabets[target]			)
  rotator()


if __name__ == "__main__":
     _UpperCamelCase    =	list(input('''Type your message:\n'''))
     while True:
          try:
               _UpperCamelCase    =	int(input('''Please set token:(must be only digits)\n'''))
               break
          except Exception as error:
               print(error)
     for _ in range(token):
          rotator()
     for j in decode:
          engine(j)
     print('''\n''' + ''''''.join(code))
     print(
         F'''\nYour Token is {token} please write it down.\nIf you want to decode '''
         '''this message again you should input same digits as token!'''
     )

