






import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


@skip_mps
class     _a							(	UpperCAmelCase__    ,							unittest.TestCase     ):






  """simple docstring"""





  A_						       = TextToVideoSDPipeline
  A_						       = TEXT_TO_IMAGE_PARAMS
  A_						       = TEXT_TO_IMAGE_BATCH_PARAMS
  # No `output_type`.
  A_						       = frozenset(
      [
          """num_inference_steps""",
          """generator""",
          """latents""",
          """return_dict""",
          """callback""",
          """callback_steps""",
      ]     )




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     torch.manual_seed(0			)
     UpperCamelCase_						=  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		,		)
     UpperCamelCase_						=  DDIMScheduler(
         beta_start=0.0_0_0_8_5		,		beta_end=0.0_1_2		,		beta_schedule='scaled_linear'		,		clip_sample=_UpperCAmelCase		,		set_alpha_to_one=_UpperCAmelCase		,		)
     torch.manual_seed(0			)
     UpperCamelCase_						=  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			)
     UpperCamelCase_						=  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=1000		,		hidden_act='gelu'		,		projection_dim=512		,		)
     UpperCamelCase_						=  CLIPTextModel(_UpperCAmelCase			)
     UpperCamelCase_						=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)

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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase=0			)      ->			Optional[Any]:
     if str(_UpperCAmelCase			).startswith('mps'			):
        UpperCamelCase_						=  torch.manual_seed(_UpperCAmelCase			)
     else:
        UpperCamelCase_						=  torch.Generator(device=_UpperCAmelCase			).manual_seed(_UpperCAmelCase			)
     UpperCamelCase_						=  {
         'prompt': 'A painting of a squirrel eating a burger',
         'generator': generator,
         'num_inference_steps': 2,
         'guidance_scale': 6.0,
         'output_type': 'pt',
     }
     return inputs




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     UpperCamelCase_						=  'cpu'  # ensure determinism for the device-dependent torch.Generator
     UpperCamelCase_						=  self.get_dummy_components()
     UpperCamelCase_						=  TextToVideoSDPipeline(**_UpperCAmelCase			)
     UpperCamelCase_						=  sd_pipe.to(_UpperCAmelCase			)
     sd_pipe.set_progress_bar_config(disable=_UpperCAmelCase			)

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

     assert frames[0].shape == (64, 64, 3)
     UpperCamelCase_						=  np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0]			)

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




  def  _UpperCAmelCase  (  self			)      ->			Any:
     self._test_attention_slicing_forward_pass(test_mean_pixel_difference=_UpperCAmelCase		,		expected_max_diff=3e-3			)




  @unittest.skipIf(
      torch_device != 'cuda' or not is_xformers_available()		,		reason='XFormers attention is only available with CUDA and `xformers` installed'		,		)
  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=_UpperCAmelCase		,		expected_max_diff=1e-2			)




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




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




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




  def  _UpperCAmelCase  (  self			)      ->			Tuple:
     return super().test_progress_bar()




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






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'			)

     UpperCamelCase_						=  TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'			)
     UpperCamelCase_						=  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config			)
     UpperCamelCase_						=  pipe.to('cuda'			)

     UpperCamelCase_						=  'Spiderman is surfing'
     UpperCamelCase_						=  torch.Generator(device='cpu'			).manual_seed(0			)

     UpperCamelCase_						=  pipe(_UpperCAmelCase		,		generator=_UpperCAmelCase		,		num_inference_steps=25		,		output_type='pt'			).frames
     UpperCamelCase_						=  video_frames.cpu().numpy()

     assert np.abs(expected_video - video			).mean() < 5e-2




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     UpperCamelCase_						=  load_numpy(
         'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'			)

     UpperCamelCase_						=  TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'			)
     UpperCamelCase_						=  pipe.to('cuda'			)

     UpperCamelCase_						=  'Spiderman is surfing'
     UpperCamelCase_						=  torch.Generator(device='cpu'			).manual_seed(0			)

     UpperCamelCase_						=  pipe(_UpperCAmelCase		,		generator=_UpperCAmelCase		,		num_inference_steps=2		,		output_type='pt'			).frames
     UpperCamelCase_						=  video_frames.cpu().numpy()

     assert np.abs(expected_video - video			).mean() < 5e-2











def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	snake_case_						       =	1
	for i in range(1	,      num + 1				):
		fact *= i
	return fact


def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	snake_case_						       =	0
	while number > 0:
		snake_case_						       =	number % 10
		sum_of_digits += last_digit
		snake_case_						       =	number // 10  # Removing the last_digit from the given number
	return sum_of_digits


def 		lowerCamelCase__       (						_A = 100				):







	'''simple docstring'''





	snake_case_						       =	factorial(_A				)
	snake_case_						       =	split_and_add(_A				)
	return result


if __name__ == "__main__":
		print(solution(int(input("Enter the Number: ").strip())))
