



'''simple docstring'''

import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


UpperCAmelCase     		=   False

class __snake_case(				unittest.TestCase ):


	'''simple docstring'''



	def     __snake_case   ( self				)     ->     List[Any]:
		# clean up the VRAM after each test
		super().tearDown()
		gc.collect()
		torch.cuda.empty_cache()


	@property
	def     __snake_case   ( self				)     ->     List[Any]:
		return 12


	@property
	def     __snake_case   ( self				)     ->     int:
		return 12


	@property
	def     __snake_case   ( self				)     ->     Optional[int]:
		return 32


	@property
	def     __snake_case   ( self				)     ->     Optional[int]:
		torch.manual_seed(0				)
		lowerCAmelCase   =     VQModel(
		    block_out_channels=[32, 64]     ,	in_channels=3     ,	out_channels=3     ,	down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]     ,	up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]     ,	latent_channels=3     ,	num_vq_embeddings=self.num_embed     ,	vq_embed_dim=3     ,	)
		return model


	@property
	def     __snake_case   ( self				)     ->     str:
		lowerCAmelCase   =     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)
		return tokenizer


	@property
	def     __snake_case   ( self				)     ->     int:
		torch.manual_seed(0				)
		lowerCAmelCase   =     CLIPTextConfig(
		    bos_token_id=0     ,	eos_token_id=2     ,	hidden_size=self.text_embedder_hidden_size     ,	intermediate_size=37     ,	layer_norm_eps=1e-05     ,	num_attention_heads=4     ,	num_hidden_layers=5     ,	pad_token_id=1     ,	vocab_size=1000     ,	)
		return CLIPTextModel(snake_case_				)


	@property
	def     __snake_case   ( self				)     ->     List[Any]:
		torch.manual_seed(0				)

		lowerCAmelCase   =     12
		lowerCAmelCase   =     12

		lowerCAmelCase   =     {
		    """attention_bias""": True,
		    """cross_attention_dim""": 32,
		    """attention_head_dim""": height * width,
		    """num_attention_heads""": 1,
		    """num_vector_embeds""": self.num_embed,
		    """num_embeds_ada_norm""": self.num_embeds_ada_norm,
		    """norm_num_groups""": 32,
		    """sample_size""": width,
		    """activation_fn""": """geglu-approximate""",
		}

		lowerCAmelCase   =     TransformeraDModel(**snake_case_				)
		return model


	def     __snake_case   ( self				)     ->     Tuple:
		lowerCAmelCase   =     """cpu"""

		lowerCAmelCase   =     self.dummy_vqvae
		lowerCAmelCase   =     self.dummy_text_encoder
		lowerCAmelCase   =     self.dummy_tokenizer
		lowerCAmelCase   =     self.dummy_transformer
		lowerCAmelCase   =     VQDiffusionScheduler(self.num_embed				)
		lowerCAmelCase   =     LearnedClassifierFreeSamplingEmbeddings(learnable=snake_case_				)

		lowerCAmelCase   =     VQDiffusionPipeline(
		    vqvae=snake_case_     ,	text_encoder=snake_case_     ,	tokenizer=snake_case_     ,	transformer=snake_case_     ,	scheduler=snake_case_     ,	learned_classifier_free_sampling_embeddings=snake_case_     ,	)
		lowerCAmelCase   =     pipe.to(snake_case_				)
		pipe.set_progress_bar_config(disable=snake_case_				)

		lowerCAmelCase   =     """teddy bear playing in the pool"""

		lowerCAmelCase   =     torch.Generator(device=snake_case_				).manual_seed(0				)
		lowerCAmelCase   =     pipe([prompt]     ,	generator=snake_case_     ,	num_inference_steps=2     ,	output_type="""np"""				)
		lowerCAmelCase   =     output.images

		lowerCAmelCase   =     torch.Generator(device=snake_case_				).manual_seed(0				)
		lowerCAmelCase   =     pipe(
		    [prompt]     ,	generator=snake_case_     ,	output_type="""np"""     ,	return_dict=snake_case_     ,	num_inference_steps=2				)[0]

		lowerCAmelCase   =     image[0, -3:, -3:, -1]
		lowerCAmelCase   =     image_from_tuple[0, -3:, -3:, -1]

		assert image.shape == (1, 24, 24, 3)

		lowerCAmelCase   =     np.array([0.6_5_5_1, 0.6_1_6_8, 0.5_0_0_8, 0.5_6_7_6, 0.5_6_5_9, 0.4_2_9_5, 0.6_0_7_3, 0.5_5_9_9, 0.4_9_9_2]				)

		assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
		assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2




	def     __snake_case   ( self				)     ->     Dict:
		lowerCAmelCase   =     """cpu"""

		lowerCAmelCase   =     self.dummy_vqvae
		lowerCAmelCase   =     self.dummy_text_encoder
		lowerCAmelCase   =     self.dummy_tokenizer
		lowerCAmelCase   =     self.dummy_transformer
		lowerCAmelCase   =     VQDiffusionScheduler(self.num_embed				)
		lowerCAmelCase   =     LearnedClassifierFreeSamplingEmbeddings(
		    learnable=snake_case_     ,	hidden_size=self.text_embedder_hidden_size     ,	length=tokenizer.model_max_length				)

		lowerCAmelCase   =     VQDiffusionPipeline(
		    vqvae=snake_case_     ,	text_encoder=snake_case_     ,	tokenizer=snake_case_     ,	transformer=snake_case_     ,	scheduler=snake_case_     ,	learned_classifier_free_sampling_embeddings=snake_case_     ,	)
		lowerCAmelCase   =     pipe.to(snake_case_				)
		pipe.set_progress_bar_config(disable=snake_case_				)

		lowerCAmelCase   =     """teddy bear playing in the pool"""

		lowerCAmelCase   =     torch.Generator(device=snake_case_				).manual_seed(0				)
		lowerCAmelCase   =     pipe([prompt]     ,	generator=snake_case_     ,	num_inference_steps=2     ,	output_type="""np"""				)
		lowerCAmelCase   =     output.images

		lowerCAmelCase   =     torch.Generator(device=snake_case_				).manual_seed(0				)
		lowerCAmelCase   =     pipe(
		    [prompt]     ,	generator=snake_case_     ,	output_type="""np"""     ,	return_dict=snake_case_     ,	num_inference_steps=2				)[0]

		lowerCAmelCase   =     image[0, -3:, -3:, -1]
		lowerCAmelCase   =     image_from_tuple[0, -3:, -3:, -1]

		assert image.shape == (1, 24, 24, 3)

		lowerCAmelCase   =     np.array([0.6_6_9_3, 0.6_0_7_5, 0.4_9_5_9, 0.5_7_0_1, 0.5_5_8_3, 0.4_3_3_3, 0.6_1_7_1, 0.5_6_8_4, 0.4_9_8_8]				)

		assert np.abs(image_slice.flatten() - expected_slice				).max() < 2.0
		assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2







@slow
@require_torch_gpu
class __snake_case(				unittest.TestCase ):


	'''simple docstring'''



	def     __snake_case   ( self				)     ->     Tuple:
		# clean up the VRAM after each test
		super().tearDown()
		gc.collect()
		torch.cuda.empty_cache()




	def     __snake_case   ( self				)     ->     Dict:
		lowerCAmelCase   =     load_numpy(
		    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
		    """/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy"""				)

		lowerCAmelCase   =     VQDiffusionPipeline.from_pretrained("""microsoft/vq-diffusion-ithq"""				)
		lowerCAmelCase   =     pipeline.to(snake_case_				)
		pipeline.set_progress_bar_config(disable=snake_case_				)

		# requires GPU generator for gumbel softmax
		# don't use GPU generator in tests though
		lowerCAmelCase   =     torch.Generator(device=snake_case_				).manual_seed(0				)
		lowerCAmelCase   =     pipeline(
		    """teddy bear playing in the pool"""     ,	num_images_per_prompt=1     ,	generator=snake_case_     ,	output_type="""np"""     ,	)

		lowerCAmelCase   =     output.images[0]

		assert image.shape == (256, 256, 3)
		assert np.abs(expected_image - image				).max() < 2.0




'''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()))))