from ...configuration_utils import PretrainedConfig
from ...utils import logging


_lowerCamelCase					:   Dict							=		logging.get_logger(__name__)

_lowerCamelCase					:   List[Any]							=		{
    '''naver-clova-ix/donut-base''': '''https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json''',
    # See all Donut models at https://huggingface.co/models?filter=donut-swin
}


class 						lowercase    (     a     ):
							lowercase__						:       List[Any]								=							"""donut-swin"""

							lowercase__						:       Any								=							{
							    """num_attention_heads""": """num_heads""",
							    """num_hidden_layers""": """num_layers""",
							}




							def __init__(						self   :					Tuple	,							_UpperCamelCase   :					Union[str, Any]=224	,							_UpperCamelCase   :					Tuple=4	,							_UpperCamelCase   :					int=3	,							_UpperCamelCase   :					List[str]=96	,							_UpperCamelCase   :					Dict=[2, 2, 6, 2]	,							_UpperCamelCase   :					Any=[3, 6, 12, 24]	,							_UpperCamelCase   :					Any=7	,							_UpperCamelCase   :					int=4.0	,							_UpperCamelCase   :					Union[str, Any]=True	,							_UpperCamelCase   :					Optional[int]=0.0	,							_UpperCamelCase   :					Optional[Any]=0.0	,							_UpperCamelCase   :					str=0.1	,							_UpperCamelCase   :					str="gelu"	,							_UpperCamelCase   :					Optional[Any]=False	,							_UpperCamelCase   :					Optional[int]=0.0_2	,							_UpperCamelCase   :					int=1e-5	,							**_UpperCamelCase   :					int	,							)					->				Tuple:



												'''simple docstring'''

												super().__init__(**__A      )

												SCREAMING_SNAKE_CASE    			=       image_size
												SCREAMING_SNAKE_CASE    			=       patch_size
												SCREAMING_SNAKE_CASE    			=       num_channels
												SCREAMING_SNAKE_CASE    			=       embed_dim
												SCREAMING_SNAKE_CASE    			=       depths
												SCREAMING_SNAKE_CASE    			=       len(__A      )
												SCREAMING_SNAKE_CASE    			=       num_heads
												SCREAMING_SNAKE_CASE    			=       window_size
												SCREAMING_SNAKE_CASE    			=       mlp_ratio
												SCREAMING_SNAKE_CASE    			=       qkv_bias
												SCREAMING_SNAKE_CASE    			=       hidden_dropout_prob
												SCREAMING_SNAKE_CASE    			=       attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE    			=       drop_path_rate
												SCREAMING_SNAKE_CASE    			=       hidden_act
												SCREAMING_SNAKE_CASE    			=       use_absolute_embeddings
												SCREAMING_SNAKE_CASE    			=       layer_norm_eps
												SCREAMING_SNAKE_CASE    			=       initializer_range
												# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
												# this indicates the channel dimension after the last stage of the model
												SCREAMING_SNAKE_CASE    			=       int(embed_dim * 2 ** (len(__A      ) - 1)      )





from __future__ import annotations

import math





def 	__lowerCamelCase							(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


_lowerCamelCase					:   Tuple							=		[num for num in range(3, 10_00_01, 2) if not is_prime(num)]





def 	__lowerCamelCase							(UpperCAmelCase__     :							int  ):
					if not isinstance(UpperCAmelCase__      , UpperCAmelCase__  ):
										raise ValueError("n must be an integer"  )
					if n <= 0:
										raise ValueError("n must be >= 0"  )

					SCREAMING_SNAKE_CASE    			=       []
					for num in range(len(UpperCAmelCase__  )  ):
										SCREAMING_SNAKE_CASE    			=       0
										while 2 * i * i <= odd_composites[num]:
															SCREAMING_SNAKE_CASE    			=       odd_composites[num] - 2 * i * i
															if is_prime(UpperCAmelCase__  ):
																				break
															i += 1
										else:
															list_nums.append(odd_composites[num]  )
															if len(UpperCAmelCase__  ) == n:
																				return list_nums

					return []





def 	__lowerCamelCase							():
					return compute_nums(1  )[0]


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




