




'''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     A					(	_a  ,unittest.TestCase					):
							lowercase_           =       VideoToVideoSDPipeline
							lowercase_           =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'video'}					) - {'image', 'width', 'height'}
							lowercase_           =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'video'}					) - {'image'}
							lowercase_           =       PipelineTesterMixin.required_optional_params - {'latents'}
							lowercase_           =       False

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







							def      __lowerCAmelCase    (						self :						Tuple      )    ->							Union[str, Any]:


														"""simple docstring"""


														torch.manual_seed(0      )
														_a			  =       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							,    )
														_a			  =       DDIMScheduler(
														    beta_start=0.0_0_0_8_5							,    beta_end=0.0_1_2							,    beta_schedule='''scaled_linear'''							,    clip_sample=lowerCAmelCase_							,    set_alpha_to_one=lowerCAmelCase_							,    )
														torch.manual_seed(0      )
														_a			  =       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=1_28							,    )
														torch.manual_seed(0      )
														_a			  =       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=10_00							,    hidden_act='''gelu'''							,    projection_dim=5_12							,    )
														_a			  =       CLIPTextModel(lowerCAmelCase_      )
														_a			  =       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

														_a			  =       {
														    '''unet''': unet,
														    '''scheduler''': scheduler,
														    '''vae''': vae,
														    '''text_encoder''': text_encoder,
														    '''tokenizer''': tokenizer,
														}
														return components







							def      __lowerCAmelCase    (						self :						List[str]							,    lowerCAmelCase_ :						Dict							,    lowerCAmelCase_ :						Any=0      )    ->							Optional[int]:


														"""simple docstring"""


														_a			  =       floats_tensor((1, 3, 3, 32, 32)							,    rng=random.Random(lowerCAmelCase_      )      ).to(lowerCAmelCase_      )

														if str(lowerCAmelCase_      ).startswith('''mps'''      ):
																					_a			  =       torch.manual_seed(lowerCAmelCase_      )
														else:
																					_a			  =       torch.Generator(device=lowerCAmelCase_      ).manual_seed(lowerCAmelCase_      )
														_a			  =       {
														    '''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      __lowerCAmelCase    (						self :						List[Any]      )    ->							Tuple:


														"""simple docstring"""


														_a			  =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
														_a			  =       self.get_dummy_components()
														_a			  =       VideoToVideoSDPipeline(**lowerCAmelCase_      )
														_a			  =       sd_pipe.to(lowerCAmelCase_      )
														sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_      )

														_a			  =       self.get_dummy_inputs(lowerCAmelCase_      )
														_a			  =       '''np'''
														_a			  =       sd_pipe(**lowerCAmelCase_      ).frames
														_a			  =       frames[0][-3:, -3:, -1]

														assert frames[0].shape == (32, 32, 3)
														_a			  =       np.array([1_06, 1_17, 1_13, 1_74, 1_37, 1_12, 1_48, 1_51, 1_31]      )

														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      __lowerCAmelCase    (						self :						int      )    ->							List[str]:


														"""simple docstring"""


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







							@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''      )
							def      __lowerCAmelCase    (						self :						Optional[int]      )    ->							List[Any]:


														"""simple docstring"""


														pass







							@unittest.skip(reason='''Batching needs to be properly figured out first for this pipeline.'''      )
							def      __lowerCAmelCase    (						self :						List[Any]      )    ->							Optional[int]:


														"""simple docstring"""


														pass







							@unittest.skip(reason='''`num_images_per_prompt` argument is not supported for this pipeline.'''      )
							def      __lowerCAmelCase    (						self :						Dict      )    ->							int:


														"""simple docstring"""


														pass







							def      __lowerCAmelCase    (						self :						int      )    ->							Optional[Any]:


														"""simple docstring"""


														return super().test_progress_bar()



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







							def      __lowerCAmelCase    (						self :						Optional[Any]      )    ->							int:


														"""simple docstring"""


														_a			  =       VideoToVideoSDPipeline.from_pretrained('''cerspense/zeroscope_v2_XL'''							,    torch_dtype=torch.floataa      )
														pipe.enable_model_cpu_offload()

														# 10 frames
														_a			  =       torch.Generator(device='''cpu'''      ).manual_seed(0      )
														_a			  =       torch.randn((1, 10, 3, 10_24, 5_76)							,    generator=lowerCAmelCase_      )
														_a			  =       video.to('''cuda'''      )

														_a			  =       '''Spiderman is surfing'''

														_a			  =       pipe(lowerCAmelCase_							,    video=lowerCAmelCase_							,    generator=lowerCAmelCase_							,    num_inference_steps=3							,    output_type='''pt'''      ).frames

														_a			  =       np.array([-1.0_4_5_8_9_8_4, -1.1_2_7_9_2_9_7, -0.9_6_6_3_0_8_6, -0.9_1_5_0_3_9_0_6, -0.7_5_0_9_7_6_5_6]      )
														assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array      ).sum() < 1e-2







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

