


'''simple docstring'''






from torch import nn
class 						__UpperCamelCase	(						nn.Module							):





							def __init__(  self		:Optional[Any]  ,_UpperCamelCase		:List[str]  ,_UpperCamelCase		:Dict			):
									super().__init__()
									snake_case_		:							int			       =						class_size
									snake_case_		:							Dict			       =						embed_size
									# self.mlp1 = nn.Linear(embed_size, embed_size)
									# self.mlp2 = (nn.Linear(embed_size, class_size))
									snake_case_		:							Optional[Any]			       =						nn.Linear(_UpperCamelCase  ,_UpperCamelCase			)





							def 		a__   (  self		:Tuple  ,_UpperCamelCase		:Optional[Any]			):
									# hidden_state = nn.functional.relu(self.mlp1(hidden_state))
									# hidden_state = self.mlp2(hidden_state)
									snake_case_		:							str			       =						self.mlp(_UpperCamelCase			)
									return logits



'''simple docstring'''






from __future__ import annotations





def      UpperCAmelCase      (		lowerCamelCase_  :int ):







		'''simple docstring'''
		snake_case_		:							List[str]			       =						[True] * limit
		snake_case_		:							Union[str, Any]			       =						False
		snake_case_		:							List[str]			       =						False
		snake_case_		:							Any			       =						True

		for i in range(3				,      int(limit**0.5 + 1 )				,      2 ):
				snake_case_		:							Tuple			       =						i * 2
				while index < limit:
						snake_case_		:							Any			       =						False
						snake_case_		:							Optional[Any]			       =						index + i

		snake_case_		:							List[str]			       =						[2]

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

		return primes





def      UpperCAmelCase      (		lowerCamelCase_  :int = 1_00_00_00 ):







		'''simple docstring'''
		snake_case_		:							Optional[int]			       =						prime_sieve(lowerCamelCase_ )
		snake_case_		:							Optional[Any]			       =						0
		snake_case_		:							Optional[int]			       =						0

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

						if sol in primes:
								snake_case_		:							Optional[Any]			       =						j - i
								snake_case_		:							Tuple			       =						sol

		return largest


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