



import argparse
import os

import torch

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)


__snake_case    :		List[Any]  ={
    'sample_size': 3_2,
    'in_channels': 3,
    'out_channels': 3,
    'layers_per_block': 2,
    'num_class_embeds': 1_0_0_0,
    'block_out_channels': [3_2, 6_4],
    'attention_head_dim': 8,
    'down_block_types': [
        'ResnetDownsampleBlock2D',
        'AttnDownBlock2D',
    ],
    'up_block_types': [
        'AttnUpBlock2D',
        'ResnetUpsampleBlock2D',
    ],
    'resnet_time_scale_shift': 'scale_shift',
    'upsample_type': 'resnet',
    'downsample_type': 'resnet',
}

__snake_case    :		Dict  ={
    'sample_size': 6_4,
    'in_channels': 3,
    'out_channels': 3,
    'layers_per_block': 3,
    'num_class_embeds': 1_0_0_0,
    'block_out_channels': [1_9_2, 1_9_2 * 2, 1_9_2 * 3, 1_9_2 * 4],
    'attention_head_dim': 6_4,
    'down_block_types': [
        'ResnetDownsampleBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
    ],
    'up_block_types': [
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'ResnetUpsampleBlock2D',
    ],
    'resnet_time_scale_shift': 'scale_shift',
    'upsample_type': 'resnet',
    'downsample_type': 'resnet',
}

__snake_case    :		Optional[Any]  ={
    'sample_size': 2_5_6,
    'in_channels': 3,
    'out_channels': 3,
    'layers_per_block': 2,
    'num_class_embeds': None,
    'block_out_channels': [2_5_6, 2_5_6, 2_5_6 * 2, 2_5_6 * 2, 2_5_6 * 4, 2_5_6 * 4],
    'attention_head_dim': 6_4,
    'down_block_types': [
        'ResnetDownsampleBlock2D',
        'ResnetDownsampleBlock2D',
        'ResnetDownsampleBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
    ],
    'up_block_types': [
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'ResnetUpsampleBlock2D',
        'ResnetUpsampleBlock2D',
        'ResnetUpsampleBlock2D',
    ],
    'resnet_time_scale_shift': 'default',
    'upsample_type': 'resnet',
    'downsample_type': 'resnet',
}

__snake_case    :		str  ={
    'num_train_timesteps': 4_0,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
}

__snake_case    :		str  ={
    'num_train_timesteps': 2_0_1,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
}

__snake_case    :		Optional[Any]  ={
    'num_train_timesteps': 1_5_1,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
}






def      lowerCAmelCase__		(   lowerCamelCase_		:		int):





				'''simple docstring'''

				if isinstance(lowerCamelCase_	,lowerCamelCase_):
								return v
				if v.lower() in ("yes", "true", "t", "y", "1"):
								return True
				elif v.lower() in ("no", "false", "f", "n", "0"):
								return False
				else:
								raise argparse.ArgumentTypeError('''boolean value expected''')






def      lowerCAmelCase__		(   lowerCamelCase_		:		List[str]	,lowerCamelCase_		:		Tuple	,lowerCamelCase_		:		Dict	,lowerCamelCase_		:		Any	,lowerCamelCase_		:		Dict=False):





				'''simple docstring'''

				lowerCAmelCase__					:    Dict												=					checkpoint[f"""{old_prefix}.in_layers.0.weight"""]
				lowerCAmelCase__					:    Dict												=					checkpoint[f"""{old_prefix}.in_layers.0.bias"""]
				lowerCAmelCase__					:    Optional[int]												=					checkpoint[f"""{old_prefix}.in_layers.2.weight"""]
				lowerCAmelCase__					:    Union[str, Any]												=					checkpoint[f"""{old_prefix}.in_layers.2.bias"""]
				lowerCAmelCase__					:    Optional[Any]												=					checkpoint[f"""{old_prefix}.emb_layers.1.weight"""]
				lowerCAmelCase__					:    List[Any]												=					checkpoint[f"""{old_prefix}.emb_layers.1.bias"""]
				lowerCAmelCase__					:    Optional[Any]												=					checkpoint[f"""{old_prefix}.out_layers.0.weight"""]
				lowerCAmelCase__					:    int												=					checkpoint[f"""{old_prefix}.out_layers.0.bias"""]
				lowerCAmelCase__					:    Optional[Any]												=					checkpoint[f"""{old_prefix}.out_layers.3.weight"""]
				lowerCAmelCase__					:    Dict												=					checkpoint[f"""{old_prefix}.out_layers.3.bias"""]

				if has_skip:
								lowerCAmelCase__					:    str												=					checkpoint[f"""{old_prefix}.skip_connection.weight"""]
								lowerCAmelCase__					:    Dict												=					checkpoint[f"""{old_prefix}.skip_connection.bias"""]

				return new_checkpoint






def      lowerCAmelCase__		(   lowerCamelCase_		:		Tuple	,lowerCamelCase_		:		Tuple	,lowerCamelCase_		:		List[str]	,lowerCamelCase_		:		Optional[int]	,lowerCamelCase_		:		Optional[Any]=None):





				'''simple docstring'''

				lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__					:    Optional[int]												=					checkpoint[f"""{old_prefix}.qkv.weight"""].chunk(3	,dim=0)
				lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__					:    List[str]												=					checkpoint[f"""{old_prefix}.qkv.bias"""].chunk(3	,dim=0)

				lowerCAmelCase__					:    Dict												=					checkpoint[f"""{old_prefix}.norm.weight"""]
				lowerCAmelCase__					:    Tuple												=					checkpoint[f"""{old_prefix}.norm.bias"""]

				lowerCAmelCase__					:    Union[str, Any]												=					weight_q.squeeze(-1).squeeze(-1)
				lowerCAmelCase__					:    Union[str, Any]												=					bias_q.squeeze(-1).squeeze(-1)
				lowerCAmelCase__					:    int												=					weight_k.squeeze(-1).squeeze(-1)
				lowerCAmelCase__					:    Any												=					bias_k.squeeze(-1).squeeze(-1)
				lowerCAmelCase__					:    int												=					weight_v.squeeze(-1).squeeze(-1)
				lowerCAmelCase__					:    int												=					bias_v.squeeze(-1).squeeze(-1)

				lowerCAmelCase__					:    Tuple												=					(
				    checkpoint[f"""{old_prefix}.proj_out.weight"""].squeeze(-1).squeeze(-1)
				)
				lowerCAmelCase__					:    Dict												=					checkpoint[f"""{old_prefix}.proj_out.bias"""].squeeze(-1).squeeze(-1)

				return new_checkpoint






def      lowerCAmelCase__		(   lowerCamelCase_		:		str	,lowerCamelCase_		:		int):





				'''simple docstring'''

				lowerCAmelCase__					:    List[Any]												=					torch.load(lowerCamelCase_	,map_location='''cpu''')
				lowerCAmelCase__					:    str												=					{}

				lowerCAmelCase__					:    Dict												=					checkpoint['''time_embed.0.weight''']
				lowerCAmelCase__					:    Optional[int]												=					checkpoint['''time_embed.0.bias''']
				lowerCAmelCase__					:    str												=					checkpoint['''time_embed.2.weight''']
				lowerCAmelCase__					:    Dict												=					checkpoint['''time_embed.2.bias''']

				if unet_config["num_class_embeds"] is not None:
								lowerCAmelCase__					:    List[Any]												=					checkpoint['''label_emb.weight''']

				lowerCAmelCase__					:    Any												=					checkpoint['''input_blocks.0.0.weight''']
				lowerCAmelCase__					:    Dict												=					checkpoint['''input_blocks.0.0.bias''']

				lowerCAmelCase__					:    Union[str, Any]												=					unet_config['''down_block_types''']
				lowerCAmelCase__					:    str												=					unet_config['''layers_per_block''']
				lowerCAmelCase__					:    Any												=					unet_config['''attention_head_dim''']
				lowerCAmelCase__					:    Optional[Any]												=					unet_config['''block_out_channels''']
				lowerCAmelCase__					:    List[str]												=					1
				lowerCAmelCase__					:    Dict												=					channels_list[0]

				for i, layer_type in enumerate(lowerCamelCase_):
								lowerCAmelCase__					:    str												=					channels_list[i]
								lowerCAmelCase__					:    Dict												=					current_channels != prev_channels
								if layer_type == "ResnetDownsampleBlock2D":
												for j in range(lowerCamelCase_):
																lowerCAmelCase__					:    List[str]												=					f"""down_blocks.{i}.resnets.{j}"""
																lowerCAmelCase__					:    int												=					f"""input_blocks.{current_layer}.0"""
																lowerCAmelCase__					:    List[str]												=					True if j == 0 and downsample_block_has_skip else False
																lowerCAmelCase__					:    Tuple												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,has_skip=lowerCamelCase_)
																current_layer += 1

								elif layer_type == "AttnDownBlock2D":
												for j in range(lowerCamelCase_):
																lowerCAmelCase__					:    List[str]												=					f"""down_blocks.{i}.resnets.{j}"""
																lowerCAmelCase__					:    List[str]												=					f"""input_blocks.{current_layer}.0"""
																lowerCAmelCase__					:    Tuple												=					True if j == 0 and downsample_block_has_skip else False
																lowerCAmelCase__					:    Optional[Any]												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,has_skip=lowerCamelCase_)
																lowerCAmelCase__					:    int												=					f"""down_blocks.{i}.attentions.{j}"""
																lowerCAmelCase__					:    List[Any]												=					f"""input_blocks.{current_layer}.1"""
																lowerCAmelCase__					:    List[Any]												=					convert_attention(
																    lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)
																current_layer += 1

								if i != len(lowerCamelCase_) - 1:
												lowerCAmelCase__					:    List[Any]												=					f"""down_blocks.{i}.downsamplers.0"""
												lowerCAmelCase__					:    List[Any]												=					f"""input_blocks.{current_layer}.0"""
												lowerCAmelCase__					:    Tuple												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)
												current_layer += 1

								lowerCAmelCase__					:    Optional[int]												=					current_channels

				# hardcoded the mid-block for now
				lowerCAmelCase__					:    Optional[Any]												=					'''mid_block.resnets.0'''
				lowerCAmelCase__					:    List[str]												=					'''middle_block.0'''
				lowerCAmelCase__					:    Optional[int]												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)
				lowerCAmelCase__					:    Dict												=					'''mid_block.attentions.0'''
				lowerCAmelCase__					:    List[Any]												=					'''middle_block.1'''
				lowerCAmelCase__					:    Dict												=					convert_attention(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)
				lowerCAmelCase__					:    List[Any]												=					'''mid_block.resnets.1'''
				lowerCAmelCase__					:    Tuple												=					'''middle_block.2'''
				lowerCAmelCase__					:    Any												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)

				lowerCAmelCase__					:    str												=					0
				lowerCAmelCase__					:    int												=					unet_config['''up_block_types''']

				for i, layer_type in enumerate(lowerCamelCase_):
								if layer_type == "ResnetUpsampleBlock2D":
												for j in range(layers_per_block + 1):
																lowerCAmelCase__					:    Any												=					f"""up_blocks.{i}.resnets.{j}"""
																lowerCAmelCase__					:    Dict												=					f"""output_blocks.{current_layer}.0"""
																lowerCAmelCase__					:    Dict												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,has_skip=lowerCamelCase_)
																current_layer += 1

												if i != len(lowerCamelCase_) - 1:
																lowerCAmelCase__					:    int												=					f"""up_blocks.{i}.upsamplers.0"""
																lowerCAmelCase__					:    Union[str, Any]												=					f"""output_blocks.{current_layer-1}.1"""
																lowerCAmelCase__					:    Union[str, Any]												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)
								elif layer_type == "AttnUpBlock2D":
												for j in range(layers_per_block + 1):
																lowerCAmelCase__					:    Optional[Any]												=					f"""up_blocks.{i}.resnets.{j}"""
																lowerCAmelCase__					:    str												=					f"""output_blocks.{current_layer}.0"""
																lowerCAmelCase__					:    List[Any]												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,has_skip=lowerCamelCase_)
																lowerCAmelCase__					:    Optional[Any]												=					f"""up_blocks.{i}.attentions.{j}"""
																lowerCAmelCase__					:    Optional[Any]												=					f"""output_blocks.{current_layer}.1"""
																lowerCAmelCase__					:    str												=					convert_attention(
																    lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)
																current_layer += 1

												if i != len(lowerCamelCase_) - 1:
																lowerCAmelCase__					:    Optional[Any]												=					f"""up_blocks.{i}.upsamplers.0"""
																lowerCAmelCase__					:    List[str]												=					f"""output_blocks.{current_layer-1}.2"""
																lowerCAmelCase__					:    Dict												=					convert_resnet(lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_	,lowerCamelCase_)

				lowerCAmelCase__					:    int												=					checkpoint['''out.0.weight''']
				lowerCAmelCase__					:    Optional[Any]												=					checkpoint['''out.0.bias''']
				lowerCAmelCase__					:    int												=					checkpoint['''out.2.weight''']
				lowerCAmelCase__					:    List[Any]												=					checkpoint['''out.2.bias''']

				return new_checkpoint


if __name__ == "__main__":
							__snake_case    :		Optional[Any]  =argparse.ArgumentParser()

							parser.add_argument('--unet_path', default=None, type=str, required=True, help='Path to the unet.pt to convert.')
							parser.add_argument(
							    '--dump_path', default=None, type=str, required=True, help='Path to output the converted UNet model.'
							)
							parser.add_argument('--class_cond', default=True, type=str, help='Whether the model is class-conditional.')

							__snake_case    :		List[str]  =parser.parse_args()
							__snake_case    :		Dict  =strabool(args.class_cond)

							__snake_case    :		str  =os.path.basename(args.unet_path)
							print(f"""Checkpoint: {ckpt_name}""")

							# Get U-Net config
							if "imagenet64" in ckpt_name:
														__snake_case    :		int  =IMAGENET_64_UNET_CONFIG
							elif "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)):
														__snake_case    :		Union[str, Any]  =LSUN_256_UNET_CONFIG
							elif "test" in ckpt_name:
														__snake_case    :		List[Any]  =TEST_UNET_CONFIG
							else:
														raise ValueError(f"""Checkpoint type {ckpt_name} is not currently supported.""")

							if not args.class_cond:
														__snake_case    :		Optional[int]  =None

							__snake_case    :		List[Any]  =con_pt_to_diffuser(args.unet_path, unet_config)

							__snake_case    :		Optional[int]  =UNetaDModel(**unet_config)
							image_unet.load_state_dict(converted_unet_ckpt)

							# Get scheduler config
							if "cd" in ckpt_name or "test" in ckpt_name:
														__snake_case    :		Dict  =CD_SCHEDULER_CONFIG
							elif "ct" in ckpt_name and "imagenet64" in ckpt_name:
														__snake_case    :		Optional[Any]  =CT_IMAGENET_64_SCHEDULER_CONFIG
							elif "ct" in ckpt_name and "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)):
														__snake_case    :		Optional[int]  =CT_LSUN_256_SCHEDULER_CONFIG
							else:
														raise ValueError(f"""Checkpoint type {ckpt_name} is not currently supported.""")

							__snake_case    :		Union[str, Any]  =CMStochasticIterativeScheduler(**scheduler_config)

							__snake_case    :		Any  =ConsistencyModelPipeline(unet=image_unet, scheduler=cm_scheduler)
							consistency_model.save_pretrained(args.dump_path)






from math import factorial






def      lowerCAmelCase__		(   lowerCamelCase_		:		int = 100):





				'''simple docstring'''

				return sum(map(lowerCamelCase_	,str(factorial(lowerCamelCase_))))


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

