



'''simple docstring'''

import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import 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 SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
				from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor

class __snake_case:


	'''simple docstring'''



	def __init__( self     ,	A_     ,	A_=13     ,	A_=32     ,	A_=2     ,	A_=3     ,	A_=16     ,	A_=[1, 2, 1]     ,	A_=[2, 2, 4]     ,	A_=2     ,	A_=2.0     ,	A_=True     ,	A_=0.0     ,	A_=0.0     ,	A_=0.1     ,	A_="gelu"     ,	A_=False     ,	A_=True     ,	A_=0.0_2     ,	A_=1e-5     ,	A_=True     ,	A_=None     ,	A_=True     ,	A_=10     ,	A_=8     ,	)     ->     Dict:
		lowerCAmelCase   =     parent
		lowerCAmelCase   =     batch_size
		lowerCAmelCase   =     image_size
		lowerCAmelCase   =     patch_size
		lowerCAmelCase   =     num_channels
		lowerCAmelCase   =     embed_dim
		lowerCAmelCase   =     depths
		lowerCAmelCase   =     num_heads
		lowerCAmelCase   =     window_size
		lowerCAmelCase   =     mlp_ratio
		lowerCAmelCase   =     qkv_bias
		lowerCAmelCase   =     hidden_dropout_prob
		lowerCAmelCase   =     attention_probs_dropout_prob
		lowerCAmelCase   =     drop_path_rate
		lowerCAmelCase   =     hidden_act
		lowerCAmelCase   =     use_absolute_embeddings
		lowerCAmelCase   =     patch_norm
		lowerCAmelCase   =     layer_norm_eps
		lowerCAmelCase   =     initializer_range
		lowerCAmelCase   =     is_training
		lowerCAmelCase   =     scope
		lowerCAmelCase   =     use_labels
		lowerCAmelCase   =     type_sequence_label_size
		lowerCAmelCase   =     encoder_stride


	def     __snake_case   ( self				)     ->     List[str]:
		lowerCAmelCase   =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

		lowerCAmelCase   =     self.get_config()

		return config, pixel_values, labels


	def     __snake_case   ( self				)     ->     int:
		return SwinvaConfig(
		    image_size=self.image_size     ,	patch_size=self.patch_size     ,	num_channels=self.num_channels     ,	embed_dim=self.embed_dim     ,	depths=self.depths     ,	num_heads=self.num_heads     ,	window_size=self.window_size     ,	mlp_ratio=self.mlp_ratio     ,	qkv_bias=self.qkv_bias     ,	hidden_dropout_prob=self.hidden_dropout_prob     ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,	drop_path_rate=self.drop_path_rate     ,	hidden_act=self.hidden_act     ,	use_absolute_embeddings=self.use_absolute_embeddings     ,	path_norm=self.patch_norm     ,	layer_norm_eps=self.layer_norm_eps     ,	initializer_range=self.initializer_range     ,	encoder_stride=self.encoder_stride     ,	)


	def     __snake_case   ( self     ,	A_     ,	A_     ,	A_				)     ->     int:
		lowerCAmelCase   =     SwinvaModel(config=__snake_case				)
		model.to(__snake_case				)
		model.eval()
		lowerCAmelCase   =     model(__snake_case				)

		lowerCAmelCase   =     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
		lowerCAmelCase   =     int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

		self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, expected_seq_len, expected_dim)				)


	def     __snake_case   ( self     ,	A_     ,	A_     ,	A_				)     ->     List[str]:
		lowerCAmelCase   =     SwinvaForMaskedImageModeling(config=__snake_case				)
		model.to(__snake_case				)
		model.eval()
		lowerCAmelCase   =     model(__snake_case				)
		self.parent.assertEqual(
		    result.logits.shape     ,	(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

		# test greyscale images
		lowerCAmelCase   =     1
		lowerCAmelCase   =     SwinvaForMaskedImageModeling(__snake_case				)
		model.to(__snake_case				)
		model.eval()

		lowerCAmelCase   =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
		lowerCAmelCase   =     model(__snake_case				)
		self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, 1, self.image_size, self.image_size)				)


	def     __snake_case   ( self     ,	A_     ,	A_     ,	A_				)     ->     Optional[Any]:
		lowerCAmelCase   =     self.type_sequence_label_size
		lowerCAmelCase   =     SwinvaForImageClassification(__snake_case				)
		model.to(__snake_case				)
		model.eval()
		lowerCAmelCase   =     model(__snake_case     ,	labels=__snake_case				)
		self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.type_sequence_label_size)				)




	def     __snake_case   ( self				)     ->     List[Any]:
		lowerCAmelCase   =     self.prepare_config_and_inputs()
		lowerCAmelCase,       lowerCAmelCase,       lowerCAmelCase   =     config_and_inputs
		lowerCAmelCase   =     {"""pixel_values""": pixel_values}
		return config, inputs_dict







@require_torch
class __snake_case(				lowerCamelCase_		,							lowerCamelCase_		,							unittest.TestCase ):


	'''simple docstring'''



	UpperCAmelCase							:   Any									=		(
	    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
	)
	UpperCAmelCase							:   List[str]									=		(
	    {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
	    if is_torch_available()
	    else {}
	)

	UpperCAmelCase							:   Tuple									=		False
	UpperCAmelCase							:   str									=		False
	UpperCAmelCase							:   Dict									=		False
	UpperCAmelCase							:   Union[str, Any]									=		False


	def     __snake_case   ( self				)     ->     Optional[Any]:
		lowerCAmelCase   =     SwinvaModelTester(self				)
		lowerCAmelCase   =     ConfigTester(self     ,	config_class=__snake_case     ,	embed_dim=37				)


	def     __snake_case   ( self				)     ->     List[Any]:
		self.config_tester.create_and_test_config_to_json_string()
		self.config_tester.create_and_test_config_to_json_file()
		self.config_tester.create_and_test_config_from_and_save_pretrained()
		self.config_tester.create_and_test_config_with_num_labels()
		self.config_tester.check_config_can_be_init_without_params()
		self.config_tester.check_config_arguments_init()


	def     __snake_case   ( self				)     ->     str:
		lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*__snake_case				)


	@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""				)
	def     __snake_case   ( self				)     ->     Optional[Any]:
		pass


	@unittest.skip(reason="""Swinv2 does not use inputs_embeds"""				)
	def     __snake_case   ( self				)     ->     Dict:
		pass


	def     __snake_case   ( self				)     ->     Optional[int]:
		lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()

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


	def     __snake_case   ( self				)     ->     List[Any]:
		lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()

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

			lowerCAmelCase   =     ["""pixel_values"""]
			self.assertListEqual(arg_names[:1]     ,	__snake_case				)


	def     __snake_case   ( self				)     ->     Dict:
		lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()
		lowerCAmelCase   =     True

		for model_class in self.all_model_classes:
			lowerCAmelCase   =     True
			lowerCAmelCase   =     False
			lowerCAmelCase   =     True
			lowerCAmelCase   =     model_class(__snake_case				)
			model.to(__snake_case				)
			model.eval()
			with torch.no_grad():
				lowerCAmelCase   =     model(**self._prepare_for_class(__snake_case     ,	__snake_case				)				)
			lowerCAmelCase   =     outputs.attentions
			lowerCAmelCase   =     len(self.model_tester.depths				)
			self.assertEqual(len(__snake_case				)     ,	__snake_case				)

			# check that output_attentions also work using config
			del inputs_dict["output_attentions"]
			lowerCAmelCase   =     True
			lowerCAmelCase   =     config.window_size**2
			lowerCAmelCase   =     model_class(__snake_case				)
			model.to(__snake_case				)
			model.eval()
			with torch.no_grad():
				lowerCAmelCase   =     model(**self._prepare_for_class(__snake_case     ,	__snake_case				)				)
			lowerCAmelCase   =     outputs.attentions
			self.assertEqual(len(__snake_case				)     ,	__snake_case				)

			self.assertListEqual(
			    list(attentions[0].shape[-3:]				)     ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,	)
			lowerCAmelCase   =     len(__snake_case				)

			# Check attention is always last and order is fine
			lowerCAmelCase   =     True
			lowerCAmelCase   =     True
			lowerCAmelCase   =     model_class(__snake_case				)
			model.to(__snake_case				)
			model.eval()
			with torch.no_grad():
				lowerCAmelCase   =     model(**self._prepare_for_class(__snake_case     ,	__snake_case				)				)

			if hasattr(self.model_tester     ,	"""num_hidden_states_types"""				):
				lowerCAmelCase   =     self.model_tester.num_hidden_states_types
			else:
				# also another +1 for reshaped_hidden_states
				lowerCAmelCase   =     2
			self.assertEqual(out_len + added_hidden_states     ,	len(__snake_case				)				)

			lowerCAmelCase   =     outputs.attentions

			self.assertEqual(len(__snake_case				)     ,	__snake_case				)

			self.assertListEqual(
			    list(self_attentions[0].shape[-3:]				)     ,	[self.model_tester.num_heads[0], window_size_squared, window_size_squared]     ,	)


	def     __snake_case   ( self     ,	A_     ,	A_     ,	A_     ,	A_				)     ->     List[str]:
		lowerCAmelCase   =     model_class(__snake_case				)
		model.to(__snake_case				)
		model.eval()

		with torch.no_grad():
			lowerCAmelCase   =     model(**self._prepare_for_class(__snake_case     ,	__snake_case				)				)

		lowerCAmelCase   =     outputs.hidden_states

		lowerCAmelCase   =     getattr(
		    self.model_tester     ,	"""expected_num_hidden_layers"""     ,	len(self.model_tester.depths				) + 1				)
		self.assertEqual(len(__snake_case				)     ,	__snake_case				)

		# Swinv2 has a different seq_length
		lowerCAmelCase   =     (
		    config.patch_size
		    if isinstance(config.patch_size     ,	collections.abc.Iterable				)
		    else (config.patch_size, config.patch_size)
		)

		lowerCAmelCase   =     (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

		self.assertListEqual(
		    list(hidden_states[0].shape[-2:]				)     ,	[num_patches, self.model_tester.embed_dim]     ,	)

		lowerCAmelCase   =     outputs.reshaped_hidden_states
		self.assertEqual(len(__snake_case				)     ,	__snake_case				)

		lowerCAmelCase,       lowerCAmelCase,       lowerCAmelCase,       lowerCAmelCase   =     reshaped_hidden_states[0].shape
		lowerCAmelCase   =     (
		    reshaped_hidden_states[0].view(__snake_case     ,	__snake_case     ,	height * width				).permute(0     ,	2     ,	1				)
		)
		self.assertListEqual(
		    list(reshaped_hidden_states.shape[-2:]				)     ,	[num_patches, self.model_tester.embed_dim]     ,	)


	def     __snake_case   ( self				)     ->     int:
		lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()

		lowerCAmelCase   =     (
		    self.model_tester.image_size
		    if isinstance(self.model_tester.image_size     ,	collections.abc.Iterable				)
		    else (self.model_tester.image_size, self.model_tester.image_size)
		)

		for model_class in self.all_model_classes:
			lowerCAmelCase   =     True
			self.check_hidden_states_output(__snake_case     ,	__snake_case     ,	__snake_case     ,	__snake_case				)

			# check that output_hidden_states also work using config
			del inputs_dict["output_hidden_states"]
			lowerCAmelCase   =     True

			self.check_hidden_states_output(__snake_case     ,	__snake_case     ,	__snake_case     ,	__snake_case				)


	def     __snake_case   ( self				)     ->     Union[str, Any]:
		lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()
		lowerCAmelCase   =     3

		lowerCAmelCase   =     (
		    self.model_tester.image_size
		    if isinstance(self.model_tester.image_size     ,	collections.abc.Iterable				)
		    else (self.model_tester.image_size, self.model_tester.image_size)
		)
		lowerCAmelCase   =     (
		    config.patch_size
		    if isinstance(config.patch_size     ,	collections.abc.Iterable				)
		    else (config.patch_size, config.patch_size)
		)

		lowerCAmelCase   =     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
		lowerCAmelCase   =     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

		for model_class in self.all_model_classes:
			lowerCAmelCase   =     True
			self.check_hidden_states_output(__snake_case     ,	__snake_case     ,	__snake_case     ,	(padded_height, padded_width)				)

			# check that output_hidden_states also work using config
			del inputs_dict["output_hidden_states"]
			lowerCAmelCase   =     True
			self.check_hidden_states_output(__snake_case     ,	__snake_case     ,	__snake_case     ,	(padded_height, padded_width)				)


	def     __snake_case   ( self				)     ->     Any:
		lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_masked_image_modeling(*__snake_case				)


	def     __snake_case   ( self				)     ->     Union[str, Any]:
		lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*__snake_case				)


	@slow
	def     __snake_case   ( self				)     ->     Tuple:
		for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			lowerCAmelCase   =     SwinvaModel.from_pretrained(__snake_case				)
			self.assertIsNotNone(__snake_case				)




	def     __snake_case   ( self				)     ->     Any:
		lowerCAmelCase,       lowerCAmelCase   =     self.model_tester.prepare_config_and_inputs_for_common()

		lowerCAmelCase   =     _config_zero_init(__snake_case				)
		for model_class in self.all_model_classes:
			lowerCAmelCase   =     model_class(config=__snake_case				)
			for name, param in model.named_parameters():
				if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
					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'     ,	)







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


	'''simple docstring'''



	@cached_property
	def     __snake_case   ( self				)     ->     str:
		return (
		    AutoImageProcessor.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""				)
		    if is_vision_available()
		    else None
		)




	@slow
	def     __snake_case   ( self				)     ->     Any:
		lowerCAmelCase   =     SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""				).to(
		    __snake_case				)
		lowerCAmelCase   =     self.default_image_processor

		lowerCAmelCase   =     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
		lowerCAmelCase   =     image_processor(images=__snake_case     ,	return_tensors="""pt"""				).to(__snake_case				)

		# forward pass
		with torch.no_grad():
			lowerCAmelCase   =     model(**__snake_case				)

		# verify the logits
		lowerCAmelCase   =     torch.Size((1, 1000)				)
		self.assertEqual(outputs.logits.shape     ,	__snake_case				)
		lowerCAmelCase   =     torch.tensor([-0.3_9_4_7, -0.4_3_0_6, 0.0_0_2_6]				).to(__snake_case				)
		self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,	__snake_case     ,	atol=1e-4				)				)




'''simple docstring'''

from __future__ import annotations






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						int | str							)      ->						bool:







	"""simple docstring"""
	lowerCAmelCase   =     str(_SCREAMING_SNAKE_CASE							)
	return n == n[::-1]






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						int = 1_000_000							)      ->						Dict:







	"""simple docstring"""
	lowerCAmelCase   =     0

	for i in range(1							,		_SCREAMING_SNAKE_CASE							):
		if is_palindrome(_SCREAMING_SNAKE_CASE							) and is_palindrome(bin(_SCREAMING_SNAKE_CASE							).split("""b"""							)[1]							):
			total += i
	return total


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