




'''simple docstring'''


import argparse
import re

import numpy as np
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SamConfig,
    SamImageProcessor,
    SamModel,
    SamProcessor,
    SamVisionConfig,
)


_snake_case   :   Tuple     							=	{
    'iou_prediction_head.layers.0': 'iou_prediction_head.proj_in',
    'iou_prediction_head.layers.1': 'iou_prediction_head.layers.0',
    'iou_prediction_head.layers.2': 'iou_prediction_head.proj_out',
    'mask_decoder.output_upscaling.0': 'mask_decoder.upscale_conv1',
    'mask_decoder.output_upscaling.1': 'mask_decoder.upscale_layer_norm',
    'mask_decoder.output_upscaling.3': 'mask_decoder.upscale_conv2',
    'mask_downscaling.0': 'mask_embed.conv1',
    'mask_downscaling.1': 'mask_embed.layer_norm1',
    'mask_downscaling.3': 'mask_embed.conv2',
    'mask_downscaling.4': 'mask_embed.layer_norm2',
    'mask_downscaling.6': 'mask_embed.conv3',
    'point_embeddings': 'point_embed',
    'pe_layer.positional_encoding_gaussian_matrix': 'shared_embedding.positional_embedding',
    'image_encoder': 'vision_encoder',
    'neck.0': 'neck.conv1',
    'neck.1': 'neck.layer_norm1',
    'neck.2': 'neck.conv2',
    'neck.3': 'neck.layer_norm2',
    'patch_embed.proj': 'patch_embed.projection',
    '.norm': '.layer_norm',
    'blocks': 'layers',
}
def 	snake_case_					(UpperCamelCase :						Any   ):





							'''simple docstring'''


							_a			  =       {}
							state_dict.pop('''pixel_mean'''				,		UpperCamelCase   )
							state_dict.pop('''pixel_std'''				,		UpperCamelCase   )

							_a			  =       R'''.*.output_hypernetworks_mlps.(\d+).layers.(\d+).*'''

							for key, value in state_dict.items():
														for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
																					if key_to_modify in key:
																												_a			  =       key.replace(UpperCamelCase				,		UpperCamelCase   )

														if re.match(UpperCamelCase				,		UpperCamelCase   ):
																					_a			  =       int(re.match(UpperCamelCase				,		UpperCamelCase   ).group(2   )   )
																					if layer_nb == 0:
																												_a			  =       key.replace('''layers.0'''				,		'''proj_in'''   )
																					elif layer_nb == 1:
																												_a			  =       key.replace('''layers.1'''				,		'''layers.0'''   )
																					elif layer_nb == 2:
																												_a			  =       key.replace('''layers.2'''				,		'''proj_out'''   )

														_a			  =       value

							_a			  =       model_state_dict[
							    '''prompt_encoder.shared_embedding.positional_embedding'''
							]

							return model_state_dict
def 	snake_case_					(UpperCamelCase :						Optional[Any]				,		UpperCamelCase :						str				,		UpperCamelCase :						str				,		UpperCamelCase :						Optional[Any]="ybelkada/segment-anything"   ):





							'''simple docstring'''


							_a			  =       hf_hub_download(UpperCamelCase				,		f'checkpoints/{model_name}.pth'   )

							if "sam_vit_b" in model_name:
														_a			  =       SamConfig()
							elif "sam_vit_l" in model_name:
														_a			  =       SamVisionConfig(
														    hidden_size=1024				,		num_hidden_layers=24				,		num_attention_heads=16				,		global_attn_indexes=[5, 11, 17, 23]				,		)

														_a			  =       SamConfig(
														    vision_config=UpperCamelCase				,		)
							elif "sam_vit_h" in model_name:
														_a			  =       SamVisionConfig(
														    hidden_size=1280				,		num_hidden_layers=32				,		num_attention_heads=16				,		global_attn_indexes=[7, 15, 23, 31]				,		)

														_a			  =       SamConfig(
														    vision_config=UpperCamelCase				,		)

							_a			  =       torch.load(UpperCamelCase				,		map_location='''cpu'''   )
							_a			  =       replace_keys(UpperCamelCase   )

							_a			  =       SamImageProcessor()

							_a			  =       SamProcessor(image_processor=UpperCamelCase   )
							_a			  =       SamModel(UpperCamelCase   )

							hf_model.load_state_dict(UpperCamelCase   )
							_a			  =       hf_model.to('''cuda'''   )

							_a			  =       '''https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png'''
							_a			  =       Image.open(requests.get(UpperCamelCase				,		stream=UpperCamelCase   ).raw   ).convert('''RGB'''   )

							_a			  =       [[[400, 650]]]
							_a			  =       [[1]]

							_a			  =       processor(images=np.array(UpperCamelCase   )				,		return_tensors='''pt'''   ).to('''cuda'''   )

							with torch.no_grad():
														_a			  =       hf_model(**UpperCamelCase   )
							_a			  =       output.iou_scores.squeeze()

							if model_name == "sam_vit_h_4b8939":
														assert scores[-1].item() == 0.579890251159668

														_a			  =       processor(
														    images=np.array(UpperCamelCase   )				,		input_points=UpperCamelCase				,		input_labels=UpperCamelCase				,		return_tensors='''pt'''   ).to('''cuda'''   )

														with torch.no_grad():
																					_a			  =       hf_model(**UpperCamelCase   )
														_a			  =       output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9712603092193604

														_a			  =       ((75, 275, 1725, 850),)

														_a			  =       processor(images=np.array(UpperCamelCase   )				,		input_boxes=UpperCamelCase				,		return_tensors='''pt'''   ).to('''cuda'''   )

														with torch.no_grad():
																					_a			  =       hf_model(**UpperCamelCase   )
														_a			  =       output.iou_scores.squeeze()

														assert scores[-1].item() == 0.8686015605926514

														# Test with 2 points and 1 image.
														_a			  =       [[[400, 650], [800, 650]]]
														_a			  =       [[1, 1]]

														_a			  =       processor(
														    images=np.array(UpperCamelCase   )				,		input_points=UpperCamelCase				,		input_labels=UpperCamelCase				,		return_tensors='''pt'''   ).to('''cuda'''   )

														with torch.no_grad():
																					_a			  =       hf_model(**UpperCamelCase   )
														_a			  =       output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9936047792434692


if __name__ == "__main__":
				_snake_case   :   Optional[int]     							=	argparse.ArgumentParser()
				_snake_case   :   Optional[int]     							=	['sam_vit_b_01ec64', 'sam_vit_h_4b8939', 'sam_vit_l_0b3195']
				parser.add_argument(
				    '--model_name',
				    default='sam_vit_h_4b8939',
				    choices=choices,
				    type=str,
				    help='Path to hf config.json of model to convert',
				)
				parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
				parser.add_argument(
				    '--push_to_hub',
				    action='store_true',
				    help='Whether to push the model and processor to the hub after converting',
				)
				parser.add_argument(
				    '--model_hub_id',
				    default='ybelkada/segment-anything',
				    choices=choices,
				    type=str,
				    help='Path to hf config.json of model to convert',
				)

				_snake_case   :   List[str]     							=	parser.parse_args()

				convert_sam_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.model_hub_id)







'''simple docstring'''


def 	snake_case_					(UpperCamelCase :						int   ):





							'''simple docstring'''


							if n == 1 or not isinstance(UpperCamelCase				,		UpperCamelCase   ):
														return 0
							elif n == 2:
														return 1
							else:
														_a			  =       [0, 1]
														for i in range(2				,		n + 1   ):
																					sequence.append(sequence[i - 1] + sequence[i - 2]   )

														return sequence[n]
def 	snake_case_					(UpperCamelCase :						int   ):





							'''simple docstring'''


							_a			  =       0
							_a			  =       2

							while digits < n:
														index += 1
														_a			  =       len(str(fibonacci(UpperCamelCase   )   )   )

							return index
def 	snake_case_					(UpperCamelCase :						int = 1000   ):





							'''simple docstring'''


							return fibonacci_digits_index(UpperCamelCase   )


if __name__ == "__main__":
				print(solution(int(str(input()).strip())))

