
from __future__ import annotations

import math



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''

					if num <= 0:
										lowercase							=						f'{num}: Invalid input, please enter a positive integer.'
										raise ValueError(lowerCAmelCase__		)

					lowercase							=						[True] * (num + 1)
					lowercase							=						[]
					lowercase							=						2
					lowercase							=						int(math.sqrt(lowerCAmelCase__		)		)

					while start <= end:
										# If start is a prime
										if sieve[start] is True:
															prime.append(lowerCAmelCase__		)

															# Set multiples of start be False
															for i in range(start * start ,			num + 1 ,			lowerCAmelCase__		):
																				if sieve[i] is True:
																									lowercase							=						False

										start += 1

					for j in range(end + 1 ,			num + 1		):
										if sieve[j] is True:
															prime.append(lowerCAmelCase__		)

					return prime


if __name__ == "__main__":
							print(prime_sieve(int(input("Enter a positive integer: ").strip())))












"""simple docstring"""
import argparse

import requests
import torch
from PIL import Image

from transformers import SwinConfig, SwinForMaskedImageModeling, ViTImageProcessor

def 				snake_case      (   A__						):
			UpperCAmelCase_     : Dict			     =					SwinConfig(image_size=1_92						)

			if "base" in model_name:
						UpperCAmelCase_     : Any			     =					6
						UpperCAmelCase_     : Optional[Any]			     =					1_28
						UpperCAmelCase_     : Optional[int]			     =					(2, 2, 18, 2)
						UpperCAmelCase_     : List[str]			     =					(4, 8, 16, 32)
			elif "large" in model_name:
						UpperCAmelCase_     : Dict			     =					12
						UpperCAmelCase_     : int			     =					1_92
						UpperCAmelCase_     : List[Any]			     =					(2, 2, 18, 2)
						UpperCAmelCase_     : int			     =					(6, 12, 24, 48)
			else:
						raise ValueError("Model not supported, only supports base and large variants"						)

			UpperCAmelCase_     : str			     =					window_size
			UpperCAmelCase_     : Any			     =					embed_dim
			UpperCAmelCase_     : int			     =					depths
			UpperCAmelCase_     : Any			     =					num_heads

			return config

def 				snake_case      (   A__						):
			if "encoder.mask_token" in name:
						UpperCAmelCase_     : str			     =					name.replace("encoder.mask_token"	,"embeddings.mask_token"						)
			if "encoder.patch_embed.proj" in name:
						UpperCAmelCase_     : Optional[int]			     =					name.replace("encoder.patch_embed.proj"	,"embeddings.patch_embeddings.projection"						)
			if "encoder.patch_embed.norm" in name:
						UpperCAmelCase_     : List[str]			     =					name.replace("encoder.patch_embed.norm"	,"embeddings.norm"						)
			if "attn.proj" in name:
						UpperCAmelCase_     : Optional[Any]			     =					name.replace("attn.proj"	,"attention.output.dense"						)
			if "attn" in name:
						UpperCAmelCase_     : Any			     =					name.replace("attn"	,"attention.self"						)
			if "norm1" in name:
						UpperCAmelCase_     : str			     =					name.replace("norm1"	,"layernorm_before"						)
			if "norm2" in name:
						UpperCAmelCase_     : Tuple			     =					name.replace("norm2"	,"layernorm_after"						)
			if "mlp.fc1" in name:
						UpperCAmelCase_     : List[str]			     =					name.replace("mlp.fc1"	,"intermediate.dense"						)
			if "mlp.fc2" in name:
						UpperCAmelCase_     : str			     =					name.replace("mlp.fc2"	,"output.dense"						)

			if name == "encoder.norm.weight":
						UpperCAmelCase_     : List[str]			     =					"layernorm.weight"
			if name == "encoder.norm.bias":
						UpperCAmelCase_     : int			     =					"layernorm.bias"

			if "decoder" in name:
						pass
			else:
						UpperCAmelCase_     : Any			     =					"swin." + name

			return name

def 				snake_case      (   A__	,A__						):
			for key in orig_state_dict.copy().keys():
						UpperCAmelCase_     : Tuple			     =					orig_state_dict.pop(A__						)

						if "attn_mask" in key:
									pass
						elif "qkv" in key:
									UpperCAmelCase_     : Optional[int]			     =					key.split("."						)
									UpperCAmelCase_     : str			     =					int(key_split[2]						)
									UpperCAmelCase_     : Union[str, Any]			     =					int(key_split[4]						)
									UpperCAmelCase_     : Optional[Any]			     =					model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

									if "weight" in key:
												UpperCAmelCase_     : List[Any]			     =					val[:dim, :]
												UpperCAmelCase_     : str			     =					val[
												    dim : dim * 2, :
												]
												UpperCAmelCase_     : str			     =					val[-dim:, :]
									else:
												UpperCAmelCase_     : List[str]			     =					val[
												    :dim
												]
												UpperCAmelCase_     : str			     =					val[
												    dim : dim * 2
												]
												UpperCAmelCase_     : Optional[Any]			     =					val[
												    -dim:
												]
						else:
									UpperCAmelCase_     : Tuple			     =					val

			return orig_state_dict

def 				snake_case      (   A__	,A__	,A__	,A__						):
			UpperCAmelCase_     : List[Any]			     =					torch.load(A__	,map_location="cpu"						)["model"]

			UpperCAmelCase_     : Optional[Any]			     =					get_swin_config(A__						)
			UpperCAmelCase_     : List[Any]			     =					SwinForMaskedImageModeling(A__						)
			model.eval()

			UpperCAmelCase_     : str			     =					convert_state_dict(A__	,A__						)
			model.load_state_dict(A__						)

			UpperCAmelCase_     : int			     =					"http://images.cocodataset.org/val2017/000000039769.jpg"

			UpperCAmelCase_     : int			     =					ViTImageProcessor(size={"height": 1_92, "width": 1_92}						)
			UpperCAmelCase_     : Any			     =					Image.open(requests.get(A__	,stream=A__						).raw						)
			UpperCAmelCase_     : Any			     =					image_processor(images=A__	,return_tensors="pt"						)

			with torch.no_grad():
						UpperCAmelCase_     : List[Any]			     =					model(**A__						).logits

			print(outputs.keys()						)
			print("Looks ok!"						)

			if pytorch_dump_folder_path is not None:
						print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""						)
						model.save_pretrained(A__						)

						print(F"""Saving image processor to {pytorch_dump_folder_path}"""						)
						image_processor.save_pretrained(A__						)

			if push_to_hub:
						print(F"""Pushing model and image processor for {model_name} to hub"""						)
						model.push_to_hub(F"""microsoft/{model_name}"""						)
						image_processor.push_to_hub(F"""microsoft/{model_name}"""						)


if __name__ == "__main__":
			lowerCamelCase_					=      argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '''--model_name''',
			    default='''swin-base-simmim-window6-192''',
			    type=str,
			    choices=['''swin-base-simmim-window6-192''', '''swin-large-simmim-window12-192'''],
			    help='''Name of the Swin SimMIM model you\'d like to convert.''',
			)
			parser.add_argument(
			    '''--checkpoint_path''',
			    default='''/Users/nielsrogge/Documents/SwinSimMIM/simmim_pretrain__swin_base__img192_window6__100ep.pth''',
			    type=str,
			    help='''Path to the original PyTorch checkpoint (.pth file).''',
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
			)
			parser.add_argument(
			    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
			)

			lowerCamelCase_					=      parser.parse_args()
			convert_swin_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)



