



from __future__ import annotations

import math
def  snake_case						(__lowercase						)	->	Optional[int]:

						'''simple docstring'''



						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(__a						) + 1						) ,      6						):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


__SCREAMING_SNAKE_CASE						:   Optional[int]         =			[num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)]
def  snake_case						(__lowercase						)	->	Optional[Any]:

						'''simple docstring'''



						if not isinstance(__a ,      __a						):
												raise ValueError("n must be an integer"						)
						if n <= 0:
												raise ValueError("n must be >= 0"						)

						_snake_case						:					Optional[int]    =   []
						for num in range(len(__a						)						):
												_snake_case						:					List[str]    =   0
												while 2 * i * i <= odd_composites[num]:
																		_snake_case						:					Optional[Any]    =   odd_composites[num] - 2 * i * i
																		if is_prime(__a						):
																								break
																		i += 1
												else:
																		list_nums.append(odd_composites[num]						)
																		if len(__a						) == n:
																								return list_nums

						return []
def  snake_case						()	->	Optional[Any]:

						'''simple docstring'''



						return compute_nums(1						)[0]


if __name__ == "__main__":
				print(F'''{solution() = }''')
import torch
from transformers import PreTrainedModel, XLMRobertaConfig, XLMRobertaModel



class        lowercase_   (					__snake_case		):
							_lowerCamelCase						=		'M-CLIP'



							def __init__(						self				,    lowercase_=1_024				,    lowercase_=768				,    **lowercase_    ):
													_snake_case						:					str    =   transformerDimSize
													_snake_case						:					Union[str, Any]    =   imageDimSize
													super().__init__(**lowercase_    )




class        lowercase_   (					__snake_case		):
							_lowerCamelCase						=		MCLIPConfig



							def __init__(						self				,    lowercase_				,    *lowercase_				,    **lowercase_    ):
													super().__init__(lowercase_				,    *lowercase_				,    **lowercase_    )
													_snake_case						:					List[Any]    =   XLMRobertaModel(lowercase_    )
													_snake_case						:					int    =   torch.nn.Linear(
													    in_features=config.transformerDimensions				,    out_features=config.numDims    )



							def 	UpperCamelCase	(						self				,    lowercase_				,    lowercase_    ):
													_snake_case						:					Tuple    =   self.transformer(input_ids=lowercase_				,    attention_mask=lowercase_    )[0]
													_snake_case						:					Tuple    =   (embs * attention_mask.unsqueeze(2    )).sum(dim=1    ) / attention_mask.sum(dim=1    )[:, None]
													return self.LinearTransformation(lowercase_    ), embs