

def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     int = 4000000				)							->				Tuple:





    '''simple docstring'''






    A__   				=       [0, 1]
    A__   				=       0
    while fib[i] <= n:
        fib.append(fib[i] + fib[i + 1]				)
        if fib[i + 2] > n:
            break
        i += 1
    A__   				=       0
    for j in range(len(A__				) - 1				):
        if fib[j] % 2 == 0:
            total += fib[j]

    return total


if __name__ == "__main__":
     print(f"""{solution() = }""")




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						(							_UpperCAmelCase   ,							unittest.TestCase			):







    """simple docstring"""





    lowerCamelCase		     =							VideoToVideoSDPipeline
    lowerCamelCase		     =							TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'video'}			) - {'image', 'width', 'height'}
    lowerCamelCase		     =							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'video'}			) - {'image'}
    lowerCamelCase		     =							PipelineTesterMixin.required_optional_params - {'latents'}
    lowerCamelCase		     =							False

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


    def 						snake_case__					(				self			:	Tuple		)->   Optional[int]:





        '''simple docstring'''







        torch.manual_seed(0		)
        A__   				=       UNetaDConditionModel(
            block_out_channels=(3_2, 6_4, 6_4, 6_4),layers_per_block=2,sample_size=3_2,in_channels=4,out_channels=4,down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D'),up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D'),cross_attention_dim=3_2,attention_head_dim=4,)
        A__   				=       DDIMScheduler(
            beta_start=0.00_085,beta_end=0.012,beta_schedule='scaled_linear',clip_sample=lowercase_,set_alpha_to_one=lowercase_,)
        torch.manual_seed(0		)
        A__   				=       AutoencoderKL(
            block_out_channels=[3_2, 6_4],in_channels=3,out_channels=3,down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'],up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'],latent_channels=4,sample_size=1_2_8,)
        torch.manual_seed(0		)
        A__   				=       CLIPTextConfig(
            bos_token_id=0,eos_token_id=2,hidden_size=3_2,intermediate_size=3_7,layer_norm_eps=1E-05,num_attention_heads=4,num_hidden_layers=5,pad_token_id=1,vocab_size=1_0_0_0,hidden_act='gelu',projection_dim=5_1_2,)
        A__   				=       CLIPTextModel(lowercase_		)
        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 						snake_case__					(				self			:	Optional[Any],lowercase_			:	Optional[int],lowercase_			:	List[Any]=0		)->   Any:





        '''simple docstring'''







        A__   				=       floats_tensor((1, 3, 3, 3_2, 3_2),rng=random.Random(lowercase_		)		).to(lowercase_		)

        if str(lowercase_		).startswith('mps'		):
            A__   				=       torch.manual_seed(lowercase_		)
        else:
            A__   				=       torch.Generator(device=lowercase_		).manual_seed(lowercase_		)
        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 						snake_case__					(				self			:	List[Any]		)->   List[Any]:





        '''simple docstring'''







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

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

        assert frames[0].shape == (3_2, 3_2, 3)
        A__   				=       np.array([1_0_6, 1_1_7, 1_1_3, 1_7_4, 1_3_7, 1_1_2, 1_4_8, 1_5_1, 1_3_1]		)

        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 						snake_case__					(				self			:	Optional[Any]		)->   int:





        '''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 						snake_case__					(				self			:	Any		)->   Optional[int]:





        '''simple docstring'''







        pass


    @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'		)
    def 						snake_case__					(				self			:	int		)->   int:





        '''simple docstring'''







        pass


    @unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'		)
    def 						snake_case__					(				self			:	List[Any]		)->   List[str]:





        '''simple docstring'''







        pass


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





        '''simple docstring'''







        return super().test_progress_bar()




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







    """simple docstring"""





    def 						snake_case__					(				self			:	List[str]		)->   Dict:





        '''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, 1_0, 3, 1_0_2_4, 5_7_6),generator=lowercase_		)
        A__   				=       video.to('cuda'		)

        A__   				=       'Spiderman is surfing'

        A__   				=       pipe(lowercase_,video=lowercase_,generator=lowercase_,num_inference_steps=3,output_type='pt'		).frames

        A__   				=       np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]		)
        assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array		).sum() < 1E-2

