





import argparse
import os
import shutil
from pathlib import Path

import onnx
import torch
from packaging import version
from torch.onnx import export

from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline


SCREAMING_SNAKE_CASE__							:      Any         =    version.parse(version.parse(torch.__version__).base_version) < version.parse("""1.11""")






def    _A	(   lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase=False				,			):
   output_path.parent.mkdir(parents=lowerCamelCase				,			exist_ok=lowerCamelCase )
   # PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
   # so we check the torch version for backwards compatibility
   if is_torch_less_than_1_11:
      export(
          lowerCamelCase				,			lowerCamelCase				,			f=output_path.as_posix()				,			input_names=lowerCamelCase				,			output_names=lowerCamelCase				,			dynamic_axes=lowerCamelCase				,			do_constant_folding=lowerCamelCase				,			use_external_data_format=lowerCamelCase				,			enable_onnx_checker=lowerCamelCase				,			opset_version=lowerCamelCase				,			)
   else:
      export(
          lowerCamelCase				,			lowerCamelCase				,			f=output_path.as_posix()				,			input_names=lowerCamelCase				,			output_names=lowerCamelCase				,			dynamic_axes=lowerCamelCase				,			do_constant_folding=lowerCamelCase				,			opset_version=lowerCamelCase				,			)






@torch.no_grad()
def    _A	(   lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase = False ):
   a__						:    Optional[int]   		=	torch.floataa if fpaa else torch.floataa
   if fpaa and torch.cuda.is_available():
      a__						:    Tuple   		=	"cuda"
   elif fpaa and not torch.cuda.is_available():
      raise ValueError("`float16` model export is only supported on GPUs with CUDA" )
   else:
      a__						:    Union[str, Any]   		=	"cpu"
   a__						:    Tuple   		=	StableDiffusionPipeline.from_pretrained(lowerCamelCase				,			torch_dtype=lowerCamelCase ).to(lowerCamelCase )
   a__						:    str   		=	Path(lowerCamelCase )

   # TEXT ENCODER
   a__						:    Any   		=	pipeline.text_encoder.config.max_position_embeddings
   a__						:    int   		=	pipeline.text_encoder.config.hidden_size
   a__						:    List[str]   		=	pipeline.tokenizer(
       "A sample prompt"				,			padding="max_length"				,			max_length=pipeline.tokenizer.model_max_length				,			truncation=lowerCamelCase				,			return_tensors="pt"				,			)
   onnx_export(
       pipeline.text_encoder				,			model_args=(text_input.input_ids.to(device=lowerCamelCase				,			dtype=torch.intaa ))				,			output_path=output_path / "text_encoder" / "model.onnx"				,			ordered_input_names=["input_ids"]				,			output_names=["last_hidden_state", "pooler_output"]				,			dynamic_axes={
           "input_ids": {0: "batch", 1: "sequence"},
       }				,			opset=lowerCamelCase				,			)
   del pipeline.text_encoder

   # UNET
   a__						:    Optional[Any]   		=	pipeline.unet.config.in_channels
   a__						:    str   		=	pipeline.unet.config.sample_size
   a__						:    Union[str, Any]   		=	output_path / "unet" / "model.onnx"
   onnx_export(
       pipeline.unet				,			model_args=(
           torch.randn(2				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase ).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
           torch.randn(2 ).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
           torch.randn(2				,			lowerCamelCase				,			lowerCamelCase ).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
           False,
       )				,			output_path=lowerCamelCase				,			ordered_input_names=["sample", "timestep", "encoder_hidden_states", "return_dict"]				,			output_names=["out_sample"]				,			dynamic_axes={
           "sample": {0: "batch", 1: "channels", 2: "height", 3: "width"},
           "timestep": {0: "batch"},
           "encoder_hidden_states": {0: "batch", 1: "sequence"},
       }				,			opset=lowerCamelCase				,			use_external_data_format=lowerCamelCase				,			)
   a__						:    Optional[int]   		=	str(unet_path.absolute().as_posix() )
   a__						:    Optional[int]   		=	os.path.dirname(lowerCamelCase )
   a__						:    Any   		=	onnx.load(lowerCamelCase )
   # clean up existing tensor files
   shutil.rmtree(lowerCamelCase )
   os.mkdir(lowerCamelCase )
   # collate external tensor files into one
   onnx.save_model(
       lowerCamelCase				,			lowerCamelCase				,			save_as_external_data=lowerCamelCase				,			all_tensors_to_one_file=lowerCamelCase				,			location="weights.pb"				,			convert_attribute=lowerCamelCase				,			)
   del pipeline.unet

   # VAE ENCODER
   a__						:    Optional[Any]   		=	pipeline.vae
   a__						:    Dict   		=	vae_encoder.config.in_channels
   a__						:    Union[str, Any]   		=	vae_encoder.config.sample_size
   # need to get the raw tensor output (sample) from the encoder
   a__						:    int   		=	lambda lowerCamelCase				,			lowerCamelCase : vae_encoder.encode(lowerCamelCase				,			lowerCamelCase )[0].sample()
   onnx_export(
       lowerCamelCase				,			model_args=(
           torch.randn(1				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase ).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
           False,
       )				,			output_path=output_path / "vae_encoder" / "model.onnx"				,			ordered_input_names=["sample", "return_dict"]				,			output_names=["latent_sample"]				,			dynamic_axes={
           "sample": {0: "batch", 1: "channels", 2: "height", 3: "width"},
       }				,			opset=lowerCamelCase				,			)

   # VAE DECODER
   a__						:    int   		=	pipeline.vae
   a__						:    Tuple   		=	vae_decoder.config.latent_channels
   a__						:    Any   		=	vae_decoder.config.out_channels
   # forward only through the decoder part
   a__						:    Any   		=	vae_encoder.decode
   onnx_export(
       lowerCamelCase				,			model_args=(
           torch.randn(1				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase ).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
           False,
       )				,			output_path=output_path / "vae_decoder" / "model.onnx"				,			ordered_input_names=["latent_sample", "return_dict"]				,			output_names=["sample"]				,			dynamic_axes={
           "latent_sample": {0: "batch", 1: "channels", 2: "height", 3: "width"},
       }				,			opset=lowerCamelCase				,			)
   del pipeline.vae

   # SAFETY CHECKER
   if pipeline.safety_checker is not None:
      a__						:    Optional[int]   		=	pipeline.safety_checker
      a__						:    Optional[int]   		=	safety_checker.config.vision_config.num_channels
      a__						:    List[Any]   		=	safety_checker.config.vision_config.image_size
      a__						:    List[str]   		=	safety_checker.forward_onnx
      onnx_export(
          pipeline.safety_checker				,			model_args=(
              torch.randn(
                  1				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
              torch.randn(1				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase ).to(device=lowerCamelCase				,			dtype=lowerCamelCase ),
          )				,			output_path=output_path / "safety_checker" / "model.onnx"				,			ordered_input_names=["clip_input", "images"]				,			output_names=["out_images", "has_nsfw_concepts"]				,			dynamic_axes={
              "clip_input": {0: "batch", 1: "channels", 2: "height", 3: "width"},
              "images": {0: "batch", 1: "height", 2: "width", 3: "channels"},
          }				,			opset=lowerCamelCase				,			)
      del pipeline.safety_checker
      a__						:    Optional[Any]   		=	OnnxRuntimeModel.from_pretrained(output_path / "safety_checker" )
      a__						:    str   		=	pipeline.feature_extractor
   else:
      a__						:    Union[str, Any]   		=	None
      a__						:    List[Any]   		=	None

   a__						:    int   		=	OnnxStableDiffusionPipeline(
       vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / "vae_encoder" )				,			vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / "vae_decoder" )				,			text_encoder=OnnxRuntimeModel.from_pretrained(output_path / "text_encoder" )				,			tokenizer=pipeline.tokenizer				,			unet=OnnxRuntimeModel.from_pretrained(output_path / "unet" )				,			scheduler=pipeline.scheduler				,			safety_checker=lowerCamelCase				,			feature_extractor=lowerCamelCase				,			requires_safety_checker=safety_checker is not None				,			)

   onnx_pipeline.save_pretrained(lowerCamelCase )
   print("ONNX pipeline saved to"				,			lowerCamelCase )

   del pipeline
   del onnx_pipeline
   a__						:    List[Any]   		=	OnnxStableDiffusionPipeline.from_pretrained(lowerCamelCase				,			provider="CPUExecutionProvider" )
   print("ONNX pipeline is loadable" )


if __name__ == "__main__":
  SCREAMING_SNAKE_CASE__							:      Dict         =    argparse.ArgumentParser()

  parser.add_argument(
      """--model_path""",
      type=str,
      required=True,
      help="""Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).""",
  )

  parser.add_argument("""--output_path""", type=str, required=True, help="""Path to the output model.""")

  parser.add_argument(
      """--opset""",
      default=1_4,
      type=int,
      help="""The version of the ONNX operator set to use.""",
  )
  parser.add_argument("""--fp16""", action="""store_true""", default=False, help="""Export the models in `float16` mode""")

  SCREAMING_SNAKE_CASE__							:      List[str]         =    parser.parse_args()

  convert_models(args.model_path, args.output_path, args.opset, args.fpaa)








def    _A	(   lowerCamelCase ):
   a__						:    Optional[Any]   		=	1
   for i in range(1				,			num + 1 ):
      fact *= i
   return fact






def    _A	(   lowerCamelCase ):
   a__						:    List[Any]   		=	0
   while number > 0:
      a__						:    str   		=	number % 10
      sum_of_digits += last_digit
      a__						:    Dict   		=	number // 10  # Removing the last_digit from the given number
   return sum_of_digits






def    _A	(   lowerCamelCase = 100 ):
   a__						:    Any   		=	factorial(lowerCamelCase )
   a__						:    Optional[Any]   		=	split_and_add(lowerCamelCase )
   return result


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

