





import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate






def 					lowerCamelCase_						(    _UpperCamelCase			)		->						str:






				"""simple docstring"""


				return x + 2





class  __lowerCAmelCase	(      unittest.TestCase					):






			def       lowerCamelCase  (self   )					->       Union[str, Any]:


							'''simple docstring'''



							snake_case_						:   Dict           =  '''x = 3'''
							snake_case_						:   str           =  {}
							snake_case_						:   Optional[int]           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							assert result == 3
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3}   )

							snake_case_						:   Union[str, Any]           =  '''x = y'''
							snake_case_						:   Any           =  {'''y''': 5}
							snake_case_						:   str           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							# evaluate returns the value of the last assignment.
							assert result == 5
							self.assertDictEqual(__magic_name__ ,							{'''x''': 5, '''y''': 5}   )






			def       lowerCamelCase  (self   )					->       Union[str, Any]:


							'''simple docstring'''



							snake_case_						:   int           =  '''y = add_two(x)'''
							snake_case_						:   str           =  {'''x''': 3}
							snake_case_						:   Tuple           =  evaluate(__magic_name__ ,							{'''add_two''': add_two} ,							state=__magic_name__   )
							assert result == 5
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''y''': 5}   )

							# Won't work without the tool
							with CaptureStdout() as out:
											snake_case_						:   Dict           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							assert result is None
							assert "tried to execute add_two" in out.out






			def       lowerCamelCase  (self   )					->       Tuple:


							'''simple docstring'''



							snake_case_						:   Union[str, Any]           =  '''x = 3'''
							snake_case_						:   List[str]           =  {}
							snake_case_						:   Optional[Any]           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							assert result == 3
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3}   )






			def       lowerCamelCase  (self   )					->       List[str]:


							'''simple docstring'''



							snake_case_						:   str           =  '''test_dict = {\'x\': x, \'y\': add_two(x)}'''
							snake_case_						:   int           =  {'''x''': 3}
							snake_case_						:   Any           =  evaluate(__magic_name__ ,							{'''add_two''': add_two} ,							state=__magic_name__   )
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''y''': 5}   )
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )






			def       lowerCamelCase  (self   )					->       int:


							'''simple docstring'''



							snake_case_						:   Tuple           =  '''x = 3\ny = 5'''
							snake_case_						:   str           =  {}
							snake_case_						:   List[Any]           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							# evaluate returns the value of the last assignment.
							assert result == 5
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''y''': 5}   )






			def       lowerCamelCase  (self   )					->       int:


							'''simple docstring'''



							snake_case_						:   Optional[int]           =  '''text = f\'This is x: {x}.\''''
							snake_case_						:   int           =  {'''x''': 3}
							snake_case_						:   Tuple           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							# evaluate returns the value of the last assignment.
							assert result == "This is x: 3."
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''text''': '''This is x: 3.'''}   )






			def       lowerCamelCase  (self   )					->       Dict:


							'''simple docstring'''



							snake_case_						:   List[Any]           =  '''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
							snake_case_						:   str           =  {'''x''': 3}
							snake_case_						:   Optional[int]           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							# evaluate returns the value of the last assignment.
							assert result == 2
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''y''': 2}   )

							snake_case_						:   Tuple           =  {'''x''': 8}
							snake_case_						:   str           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							# evaluate returns the value of the last assignment.
							assert result == 5
							self.assertDictEqual(__magic_name__ ,							{'''x''': 8, '''y''': 5}   )






			def       lowerCamelCase  (self   )					->       List[Any]:


							'''simple docstring'''



							snake_case_						:   List[Any]           =  '''test_list = [x, add_two(x)]'''
							snake_case_						:   Dict           =  {'''x''': 3}
							snake_case_						:   List[Any]           =  evaluate(__magic_name__ ,							{'''add_two''': add_two} ,							state=__magic_name__   )
							self.assertListEqual(__magic_name__ ,							[3, 5]   )
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''test_list''': [3, 5]}   )






			def       lowerCamelCase  (self   )					->       str:


							'''simple docstring'''



							snake_case_						:   List[Any]           =  '''y = x'''
							snake_case_						:   List[Any]           =  {'''x''': 3}
							snake_case_						:   int           =  evaluate(__magic_name__ ,							{} ,							state=__magic_name__   )
							assert result == 3
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''y''': 3}   )






			def       lowerCamelCase  (self   )					->       Optional[Any]:


							'''simple docstring'''



							snake_case_						:   Dict           =  '''test_list = [x, add_two(x)]\ntest_list[1]'''
							snake_case_						:   Optional[int]           =  {'''x''': 3}
							snake_case_						:   List[Any]           =  evaluate(__magic_name__ ,							{'''add_two''': add_two} ,							state=__magic_name__   )
							assert result == 5
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''test_list''': [3, 5]}   )

							snake_case_						:   Any           =  '''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
							snake_case_						:   Tuple           =  {'''x''': 3}
							snake_case_						:   List[str]           =  evaluate(__magic_name__ ,							{'''add_two''': add_two} ,							state=__magic_name__   )
							assert result == 5
							self.assertDictEqual(__magic_name__ ,							{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )






			def       lowerCamelCase  (self   )					->       Any:


							'''simple docstring'''



							snake_case_						:   List[Any]           =  '''x = 0\nfor i in range(3):\n    x = i'''
							snake_case_						:   int           =  {}
							snake_case_						:   Optional[Any]           =  evaluate(__magic_name__ ,							{'''range''': range} ,							state=__magic_name__   )
							assert result == 2
							self.assertDictEqual(__magic_name__ ,							{'''x''': 2, '''i''': 2}   )







import random

from .binary_exp_mod import bin_exp_mod






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase=1_000			)		->						str:






				"""simple docstring"""


				if n < 2:
								return False

				if n % 2 == 0:
								return n == 2

				# this means n is odd
				snake_case_						:   int           =  n - 1
				snake_case_						:   Union[str, Any]           =  0
				while d % 2 == 0:
								d /= 2
								exp += 1

				# n - 1=d*(2**exp)
				snake_case_						:   List[Any]           =  0
				while count < prec:
								snake_case_						:   Tuple           =  random.randint(2			,    n - 1			)
								snake_case_						:   List[Any]           =  bin_exp_mod(_UpperCamelCase			,    _UpperCamelCase			,    _UpperCamelCase			)
								if b != 1:
												snake_case_						:   Any           =  True
												for _ in range(_UpperCamelCase			):
																if b == n - 1:
																				snake_case_						:   Tuple           =  False
																				break
																snake_case_						:   List[Any]           =  b * b
																b %= n
												if flag:
																return False
												count += 1
				return True


if __name__ == "__main__":
	lowerCAmelCase_    =    abs(int(input('''Enter bound : ''').strip()))
	print('''Here\'s the list of primes:''')
	print(''', '''.join(str(i) for i in range(n + 1) if is_prime_big(i)))
