




'''simple docstring'''




from __future__ import annotations





def 	a_				( __snake_case				:     int  )				->		list[int]:



       """simple docstring"""
       lowerCamelCase_				=[True] * limit
       lowerCamelCase_				=False
       lowerCamelCase_				=False
       lowerCamelCase_				=True

       for i in range(3  ,			int(limit**0.5 + 1  )  ,			2  ):
              lowerCamelCase_				=i * 2
              while index < limit:
                     lowerCamelCase_				=False
                     lowerCamelCase_				=index + i

       lowerCamelCase_				=[2]

       for i in range(3  ,			lowerCAmelCase__  ,			2  ):
              if is_prime[i]:
                     primes.append(lowerCAmelCase__  )

       return primes





def 	a_				( __snake_case				:     int = 100_0000  )				->		int:



       """simple docstring"""
       lowerCamelCase_				=prime_sieve(lowerCAmelCase__  )
       lowerCamelCase_				=0
       lowerCamelCase_				=0

       for i in range(len(lowerCAmelCase__  )  ):
              for j in range(i + length  ,			len(lowerCAmelCase__  )  ):
                     lowerCamelCase_				=sum(primes[i:j]  )
                     if sol >= ceiling:
                            break

                     if sol in primes:
                            lowerCamelCase_				=j - i
                            lowerCamelCase_				=sol

       return largest


if __name__ == "__main__":
     print(F"""{solution() = }""")











"""simple docstring"""






import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin



class 					__UpperCAmelCase							(						unittest.TestCase						,  _UpperCamelCase  ):
				def       UpperCAmelCase      (		self    :			Dict    )	->	List[Any]:



							'''simple docstring'''



							a__  :	Any		 =			load_tool("text-classification"    )
							self.tool.setup()
							a__  :	List[Any]		 =			load_tool("text-classification"	, remote=a_    )
				def       UpperCAmelCase      (		self    :			Optional[int]    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	str		 =			self.tool("That's quite cool"	, ["positive", "negative"]    )
							self.assertEqual(a_	, "positive"    )
				def       UpperCAmelCase      (		self    :			Union[str, Any]    )	->	Optional[int]:



							'''simple docstring'''



							a__  :	List[str]		 =			self.remote_tool("That's quite cool"	, ["positive", "negative"]    )
							self.assertEqual(a_	, "positive"    )
				def       UpperCAmelCase      (		self    :			Dict    )	->	Any:



							'''simple docstring'''



							a__  :	List[str]		 =			self.tool(text="That's quite cool"	, labels=["positive", "negative"]    )
							self.assertEqual(a_	, "positive"    )






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



							'''simple docstring'''



							a__  :	Tuple		 =			self.remote_tool(text="That's quite cool"	, labels=["positive", "negative"]    )
							self.assertEqual(a_	, "positive"    )