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


_lowerCAmelCase       =		logging.get_logger(__name__)

_lowerCAmelCase       =		{
    "microsoft/swinv2-tiny-patch4-window8-256": (
        "https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json"
    ),
}
class     lowerCAmelCase_     (       __lowercase ):
							UpperCAmelCase				   =     "swinv2"

							UpperCAmelCase				   =     {
							    "num_attention_heads": "num_heads",
							    "num_hidden_layers": "num_layers",
							}







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

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

from __future__ import annotations

_lowerCAmelCase       =		[True] * 1_000_001
_lowerCAmelCase       =		2
while i * i <= 1_000_000:
					if seive[i]:
										for j in range(i * i, 1_000_001, i):
															_lowerCAmelCase       =		False
					i += 1
def 					_snake_case	(  __snake_case						):
					return seive[n]
def 					_snake_case	(  __snake_case						):
					return any(digit in '''02468''' for digit in str(__snake_case						)						)
def 					_snake_case	(  __snake_case = 1000000						):
					_UpperCamelCase			     =     [2]  # result already includes the number 2.
					for num in range(3  ,     limit + 1  ,     2						):
										if is_prime(__snake_case						) and not contains_an_even_digit(__snake_case						):
															_UpperCamelCase			     =     str(__snake_case						)
															_UpperCamelCase			     =     [int(str_num[j:] + str_num[:j]						) for j in range(len(__snake_case						)						)]
															if all(is_prime(__snake_case						) for i in list_nums						):
																				result.append(__snake_case						)
					return result
def 					_snake_case	(  ):
					return len(find_circular_primes()						)


if __name__ == "__main__":
					print(f'{len(find_circular_primes()) = }')
