
'''simple docstring'''



import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




@skip_mps
class     UpperCAmelCase_	(						_SCREAMING_SNAKE_CASE			,				unittest.TestCase					):






						'''simple docstring'''






						_lowercase						: str										=  VideoToVideoSDPipeline
						_lowercase						: Tuple										=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}					) - {'''image''', '''width''', '''height'''}
						_lowercase						: List[str]										=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}					) - {'''image'''}
						_lowercase						: Tuple										=  PipelineTesterMixin.required_optional_params - {'''latents'''}
						_lowercase						: Any										=  False

						# No `output_type`.
						_lowercase						: Tuple										=  frozenset(
						    [
						        '''num_inference_steps''',
						        '''generator''',
						        '''latents''',
						        '''return_dict''',
						        '''callback''',
						        '''callback_steps''',
						    ]					)




						def    _lowercase      (   self ):

												"""simple docstring"""



												torch.manual_seed(0 )
												_lowerCAmelCase    		=					UNetaDConditionModel(
												    block_out_channels=(32, 64, 64, 64)       ,  layers_per_block=2       ,  sample_size=32       ,  in_channels=4       ,  out_channels=4       ,  down_block_types=("""CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """DownBlock3D""")       ,  up_block_types=("""UpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""")       ,  cross_attention_dim=32       ,  attention_head_dim=4       ,  )
												_lowerCAmelCase    		=					DDIMScheduler(
												    beta_start=0.0_0085       ,  beta_end=0.012       ,  beta_schedule="""scaled_linear"""       ,  clip_sample=_lowercase       ,  set_alpha_to_one=_lowercase       ,  )
												torch.manual_seed(0 )
												_lowerCAmelCase    		=					AutoencoderKL(
												    block_out_channels=[32, 64]       ,  in_channels=3       ,  out_channels=3       ,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]       ,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]       ,  latent_channels=4       ,  sample_size=128       ,  )
												torch.manual_seed(0 )
												_lowerCAmelCase    		=					CLIPTextConfig(
												    bos_token_id=0       ,  eos_token_id=2       ,  hidden_size=32       ,  intermediate_size=37       ,  layer_norm_eps=1e-05       ,  num_attention_heads=4       ,  num_hidden_layers=5       ,  pad_token_id=1       ,  vocab_size=1_000       ,  hidden_act="""gelu"""       ,  projection_dim=512       ,  )
												_lowerCAmelCase    		=					CLIPTextModel(_lowercase )
												_lowerCAmelCase    		=					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

												_lowerCAmelCase    		=					{
												    """unet""": unet,
												    """scheduler""": scheduler,
												    """vae""": vae,
												    """text_encoder""": text_encoder,
												    """tokenizer""": tokenizer,
												}
												return components




						def    _lowercase      (   self       ,  _lowercase       ,  _lowercase=0 ):

												"""simple docstring"""



												_lowerCAmelCase    		=					floats_tensor((1, 3, 3, 32, 32)       ,  rng=random.Random(_lowercase ) ).to(_lowercase )

												if str(_lowercase ).startswith("""mps""" ):
																		_lowerCAmelCase    		=					torch.manual_seed(_lowercase )
												else:
																		_lowerCAmelCase    		=					torch.Generator(device=_lowercase ).manual_seed(_lowercase )
												_lowerCAmelCase    		=					{
												    """prompt""": """A painting of a squirrel eating a burger""",
												    """video""": video,
												    """generator""": generator,
												    """num_inference_steps""": 2,
												    """guidance_scale""": 6.0,
												    """output_type""": """pt""",
												}
												return inputs




						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					"""cpu"""  # ensure determinism for the device-dependent torch.Generator
												_lowerCAmelCase    		=					self.get_dummy_components()
												_lowerCAmelCase    		=					VideoToVideoSDPipeline(**_lowercase )
												_lowerCAmelCase    		=					sd_pipe.to(_lowercase )
												sd_pipe.set_progress_bar_config(disable=_lowercase )

												_lowerCAmelCase    		=					self.get_dummy_inputs(_lowercase )
												_lowerCAmelCase    		=					"""np"""
												_lowerCAmelCase    		=					sd_pipe(**_lowercase ).frames
												_lowerCAmelCase    		=					frames[0][-3:, -3:, -1]

												assert frames[0].shape == (32, 32, 3)
												_lowerCAmelCase    		=					np.array([106, 117, 113, 174, 137, 112, 148, 151, 131] )

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




						@unittest.skipIf(
						    torch_device != """cuda""" or not is_xformers_available()       ,  reason="""XFormers attention is only available with CUDA and `xformers` installed"""       ,  )
						def    _lowercase      (   self ):

												"""simple docstring"""



												self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_lowercase       ,  expected_max_diff=5e-3 )




						@unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline.""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline.""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						@unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline.""" )
						def    _lowercase      (   self ):

												"""simple docstring"""



												pass




						def    _lowercase      (   self ):

												"""simple docstring"""



												return super().test_progress_bar()






@slow
@skip_mps
class     UpperCAmelCase_	(						unittest.TestCase					):






						'''simple docstring'''






						def    _lowercase      (   self ):

												"""simple docstring"""



												_lowerCAmelCase    		=					VideoToVideoSDPipeline.from_pretrained("""cerspense/zeroscope_v2_XL"""       ,  torch_dtype=torch.floataa )
												pipe.enable_model_cpu_offload()

												# 10 frames
												_lowerCAmelCase    		=					torch.Generator(device="""cpu""" ).manual_seed(0 )
												_lowerCAmelCase    		=					torch.randn((1, 10, 3, 1_024, 576)       ,  generator=_lowercase )
												_lowerCAmelCase    		=					video.to("""cuda""" )

												_lowerCAmelCase    		=					"""Spiderman is surfing"""

												_lowerCAmelCase    		=					pipe(_lowercase       ,  video=_lowercase       ,  generator=_lowercase       ,  num_inference_steps=3       ,  output_type="""pt""" ).frames

												_lowerCAmelCase    		=					np.array([-1.045_8984, -1.127_9297, -0.966_3086, -0.9150_3906, -0.7509_7656] )
												assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array ).sum() < 1e-2





from __future__ import annotations







def  lowerCAmelCase_	(lowerCAmelCase__:		int | str  ):





			"""simple docstring"""


			UpperCAmelCase_:		Optional[int]							      =     str(lowerCAmelCase__  )
			return n == n[::-1]







def  lowerCAmelCase_	(lowerCAmelCase__:		int = 1_0_0_0_0_0_0  ):





			"""simple docstring"""


			UpperCAmelCase_:		int							      =     0

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


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






