
'''simple docstring'''


import math
def 					__magic_name__(       UpperCAmelCase__ :       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(UpperCAmelCase__	) + 1	)							,				6	):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True
def 					__magic_name__(       UpperCAmelCase__ :       int = 1000							,				UpperCAmelCase__ :       int = 1000	):
						UpperCamelCase_     :	Optional[int]					     =     [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__	):
																								UpperCamelCase_     :	Dict					     =     0
																								UpperCamelCase_     :	List[str]					     =     0
																								while is_prime((n**2) + (a * n) + b	):
																														count += 1
																														n += 1
																								if count > longest[0]:
																														UpperCamelCase_     :	Any					     =     [count, a, b]
						UpperCamelCase_     :	int					     =     longest[1] * longest[2]
						return ans


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






'''simple docstring'''


import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
	import tensorflow as tf

	from transformers.activations_tf import get_tf_activation




@require_tf
class     __snake_case			(    unittest.TestCase	):




		def 	_snake_case	(  self					:Tuple)					->			List[Any]:






								'''simple docstring'''






								UpperCamelCase_     :	List[str]					     =     tf.constant([-1_0_0, -1.0, -0.1, 0, 0.1, 1.0, 100.0])
								UpperCamelCase_     :	Any					     =     get_tf_activation("""gelu""")
								UpperCamelCase_     :	List[Any]					     =     get_tf_activation("""gelu_10""")

								UpperCamelCase_     :	Optional[int]					     =     gelu(_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	Dict					     =     geluaa(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	List[Any]					     =     tf.where(y_gelu_aa < 10.0			,    1.0			,    0.0)

								self.assertEqual(tf.math.reduce_max(_SCREAMING_SNAKE_CASE).numpy().item()			,    10.0)
								self.assertTrue(np.allclose(y_gelu * clipped_mask			,    y_gelu_aa * clipped_mask))





		def 	_snake_case	(  self					:Any)					->			Dict:






								'''simple docstring'''






								get_tf_activation("""gelu""")
								get_tf_activation("""gelu_10""")
								get_tf_activation("""gelu_fast""")
								get_tf_activation("""gelu_new""")
								get_tf_activation("""glu""")
								get_tf_activation("""mish""")
								get_tf_activation("""quick_gelu""")
								get_tf_activation("""relu""")
								get_tf_activation("""sigmoid""")
								get_tf_activation("""silu""")
								get_tf_activation("""swish""")
								get_tf_activation("""tanh""")
								with self.assertRaises(_SCREAMING_SNAKE_CASE):
														get_tf_activation("""bogus""")
								with self.assertRaises(_SCREAMING_SNAKE_CASE):
														get_tf_activation(_SCREAMING_SNAKE_CASE)




