





'''simple docstring'''



import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
	from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image






class 							__lowercase    :







	'''simple docstring'''

	def __init__(self       ,_lowerCamelCase       ,_lowerCamelCase=13       ,_lowerCamelCase=64       ,_lowerCamelCase=2       ,_lowerCamelCase=3       ,_lowerCamelCase=True       ,_lowerCamelCase=True       ,_lowerCamelCase=32       ,_lowerCamelCase=5       ,_lowerCamelCase=4       ,_lowerCamelCase=37       ,_lowerCamelCase="gelu"       ,_lowerCamelCase=0.1       ,_lowerCamelCase=0.1       ,_lowerCamelCase=10       ,_lowerCamelCase=0.0_2       ,_lowerCamelCase=[1, 16, 4, 4]       ,_lowerCamelCase=None       ,)							->							str:







				'''simple docstring'''





				__lowercase			  =							parent
				__lowercase			  =							batch_size
				__lowercase			  =							image_size
				__lowercase			  =							patch_size
				__lowercase			  =							num_channels
				__lowercase			  =							is_training
				__lowercase			  =							use_labels
				__lowercase			  =							hidden_size
				__lowercase			  =							num_hidden_layers
				__lowercase			  =							num_attention_heads
				__lowercase			  =							intermediate_size
				__lowercase			  =							hidden_act
				__lowercase			  =							hidden_dropout_prob
				__lowercase			  =							attention_probs_dropout_prob
				__lowercase			  =							type_sequence_label_size
				__lowercase			  =							initializer_range
				__lowercase			  =							scope
				__lowercase			  =							backbone_featmap_shape

				# in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
				# the number of patches is based on the feature map of the backbone, which by default uses an output stride
				# of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
				__lowercase			  =							(self.image_size // 32) ** 2
				__lowercase			  =							num_patches + 1


	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





				__lowercase			  =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

				__lowercase			  =							None
				if self.use_labels:
							__lowercase			  =							ids_tensor([self.batch_size]       ,self.type_sequence_label_size	)

				__lowercase			  =							self.get_config()

				return config, pixel_values, labels


	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				__lowercase			  =							{
				    '''global_padding''': '''same''',
				    '''layer_type''': '''bottleneck''',
				    '''depths''': [3, 4, 9],
				    '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
				    '''embedding_dynamic_padding''': True,
				    '''hidden_sizes''': [4, 8, 16, 32],
				    '''num_groups''': 2,
				}

				return ViTHybridConfig(
				    image_size=self.image_size       ,patch_size=self.patch_size       ,num_channels=self.num_channels       ,hidden_size=self.hidden_size       ,num_hidden_layers=self.num_hidden_layers       ,num_attention_heads=self.num_attention_heads       ,intermediate_size=self.intermediate_size       ,hidden_act=self.hidden_act       ,hidden_dropout_prob=self.hidden_dropout_prob       ,attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,is_decoder=_lowerCamelCase       ,initializer_range=self.initializer_range       ,backbone_featmap_shape=self.backbone_featmap_shape       ,backbone_config=_lowerCamelCase       ,)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	)							->							Optional[Any]:







				'''simple docstring'''





				__lowercase			  =							ViTHybridModel(config=_lowerCamelCase	)
				model.to(_lowerCamelCase	)
				model.eval()
				__lowercase			  =							model(_lowerCamelCase	)
				self.parent.assertEqual(result.last_hidden_state.shape       ,(self.batch_size, self.seq_length, self.hidden_size)	)


	def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase       ,_lowerCamelCase	)							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase			  =							self.type_sequence_label_size
				__lowercase			  =							ViTHybridForImageClassification(_lowerCamelCase	)
				model.to(_lowerCamelCase	)
				model.eval()
				__lowercase			  =							model(_lowerCamelCase       ,labels=_lowerCamelCase	)
				self.parent.assertEqual(result.logits.shape       ,(self.batch_size, self.type_sequence_label_size)	)


	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				__lowercase			  =							self.prepare_config_and_inputs()
				__lowercase  ,						__lowercase  ,						__lowercase			  =							config_and_inputs
				__lowercase			  =							{'''pixel_values''': pixel_values}
				return config, inputs_dict






@require_torch
class 							__lowercase    ( lowerCAmelCase__	, lowerCAmelCase__	, unittest.TestCase  ):







	'''simple docstring'''

	a      :			int     =    (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
	a      :			int     =    (
	    {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
	    if is_torch_available()
	    else {}
	)
	a      :			Dict     =    False
	a      :			Dict     =    False
	a      :			Union[str, Any]     =    False


	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				__lowercase			  =							ViTHybridModelTester(self	)
				__lowercase			  =							ConfigTester(self       ,config_class=_lowerCamelCase       ,has_text_modality=_lowerCamelCase       ,hidden_size=37	)


	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				self.config_tester.run_common_tests()


	@unittest.skip(reason='''ViT does not use inputs_embeds'''	)
	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				pass


	def   _UpperCAmelCase       (self	)							->							int:







				'''simple docstring'''





				__lowercase  ,						__lowercase			  =							self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							__lowercase			  =							model_class(_lowerCamelCase	)
							self.assertIsInstance(model.get_input_embeddings()       ,(nn.Module)	)
							__lowercase			  =							model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(_lowerCamelCase       ,nn.Linear	)	)


	def   _UpperCAmelCase       (self	)							->							Any:







				'''simple docstring'''





				__lowercase  ,						__lowercase			  =							self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							__lowercase			  =							model_class(_lowerCamelCase	)
							__lowercase			  =							inspect.signature(model.forward	)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							__lowercase			  =							[*signature.parameters.keys()]

							__lowercase			  =							['''pixel_values''']
							self.assertListEqual(arg_names[:1]       ,_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							List[str]:







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				__lowercase			  =							self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase	)


	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				__lowercase  ,						__lowercase			  =							self.model_tester.prepare_config_and_inputs_for_common()

				__lowercase			  =							_config_zero_init(_lowerCamelCase	)
				for model_class in self.all_model_classes:
							__lowercase			  =							model_class(config=_lowerCamelCase	)
							# Skip the check for the backbone
							for name, module in model.named_modules():
										if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
													__lowercase			  =							[f"{name}.{key}" for key in module.state_dict().keys()]
													break

							for name, param in model.named_parameters():
										if param.requires_grad:
													if name in backbone_params:
																continue
													self.assertIn(
													    ((param.data.mean() * 1E9).round() / 1E9).item()       ,[0.0, 1.0]       ,msg=f"Parameter {name} of model {model_class} seems not properly initialized"       ,)


	@slow
	def   _UpperCAmelCase       (self	)							->							Tuple:







				'''simple docstring'''





				for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowercase			  =							ViTHybridModel.from_pretrained(_lowerCamelCase	)
							self.assertIsNotNone(_lowerCamelCase	)





def 				_lowerCAmelCase  (			):
			__lowercase			  =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
			return image






@require_torch
@require_vision
class 							__lowercase    ( unittest.TestCase  ):







	'''simple docstring'''

	@cached_property
	def   _UpperCAmelCase       (self	)							->							Optional[int]:







				'''simple docstring'''





				return (
				    ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
				    if is_vision_available()
				    else None
				)


	@slow
	def   _UpperCAmelCase       (self	)							->							Optional[Any]:







				'''simple docstring'''





				__lowercase			  =							ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(
				    _lowerCamelCase	)

				__lowercase			  =							self.default_image_processor
				__lowercase			  =							prepare_img()
				__lowercase			  =							image_processor(images=_lowerCamelCase       ,return_tensors='''pt'''	).to(_lowerCamelCase	)

				# forward pass
				with torch.no_grad():
							__lowercase			  =							model(**_lowerCamelCase	)

				# verify the logits
				__lowercase			  =							torch.Size((1, 1000)	)
				self.assertEqual(outputs.logits.shape       ,_lowerCamelCase	)

				__lowercase			  =							torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9]	).to(_lowerCamelCase	)

				self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,_lowerCamelCase       ,atol=1E-4	)	)


	@slow
	@require_accelerate
	def   _UpperCAmelCase       (self	)							->							List[Any]:







				'''simple docstring'''





				__lowercase			  =							ViTHybridImageProcessor.from_pretrained('''google/vit-hybrid-base-bit-384'''	)
				__lowercase			  =							ViTHybridForImageClassification.from_pretrained('''google/vit-hybrid-base-bit-384'''       ,device_map='''auto'''	)

				__lowercase			  =							prepare_img()

				__lowercase			  =							image_processor(images=_lowerCamelCase       ,return_tensors='''pt'''	)
				__lowercase			  =							model(**_lowerCamelCase	)
				__lowercase			  =							outputs.logits
				# model predicts one of the 1000 ImageNet classes
				__lowercase			  =							logits.argmax(-1	).item()

				self.assertTrue(model.config.idalabel[predicted_class_idx]       ,'''tabby, tabby cat'''	)












'''simple docstring'''



from math import sqrt




def 				_lowerCAmelCase  (			lowerCamelCase_     :					int			):
			__lowercase			  =							0
			for i in range(1						,    int(sqrt(lowerCamelCase_			) + 1			)			):
						if n % i == 0 and i != sqrt(lowerCamelCase_			):
									total += i + n // i
						elif i == sqrt(lowerCamelCase_			):
									total += i
			return total - n




def 				_lowerCAmelCase  (			lowerCamelCase_     :					int = 1_0_0_0_0			):
			__lowercase			  =							sum(
			    i
			    for i in range(1						,    lowerCamelCase_			)
			    if sum_of_divisors(sum_of_divisors(lowerCamelCase_			)			) == i and sum_of_divisors(lowerCamelCase_			) != i			)
			return total


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





