"""simple docstring"""






import argparse
import os

import torch

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)


__A			   = {
    "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",
}

__A			   = {
    "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",
}

__A			   = {
    "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",
}

__A			   = {
    "num_train_timesteps": 4_0,
    "sigma_min": 0.002,
    "sigma_max": 80.0,
}

__A			   = {
    "num_train_timesteps": 2_0_1,
    "sigma_min": 0.002,
    "sigma_max": 80.0,
}

__A			   = {
    "num_train_timesteps": 1_5_1,
    "sigma_min": 0.002,
    "sigma_max": 80.0,
}



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  Optional[int]:
   if isinstance(__UpperCAmelCase       ,    __UpperCAmelCase ):
      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 SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase=False )  ->  Any:
   lowercase__:   Tuple					=      checkpoint[F"""{old_prefix}.in_layers.0.weight"""]
   lowercase__:   int					=      checkpoint[F"""{old_prefix}.in_layers.0.bias"""]
   lowercase__:   Any					=      checkpoint[F"""{old_prefix}.in_layers.2.weight"""]
   lowercase__:   Dict					=      checkpoint[F"""{old_prefix}.in_layers.2.bias"""]
   lowercase__:   str					=      checkpoint[F"""{old_prefix}.emb_layers.1.weight"""]
   lowercase__:   Tuple					=      checkpoint[F"""{old_prefix}.emb_layers.1.bias"""]
   lowercase__:   List[Any]					=      checkpoint[F"""{old_prefix}.out_layers.0.weight"""]
   lowercase__:   List[str]					=      checkpoint[F"""{old_prefix}.out_layers.0.bias"""]
   lowercase__:   Any					=      checkpoint[F"""{old_prefix}.out_layers.3.weight"""]
   lowercase__:   Optional[int]					=      checkpoint[F"""{old_prefix}.out_layers.3.bias"""]

   if has_skip:
      lowercase__:   int					=      checkpoint[F"""{old_prefix}.skip_connection.weight"""]
      lowercase__:   Union[str, Any]					=      checkpoint[F"""{old_prefix}.skip_connection.bias"""]

   return new_checkpoint



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase=None )  ->  Optional[int]:
   lowercase__, lowercase__, lowercase__:   str					=      checkpoint[F"""{old_prefix}.qkv.weight"""].chunk(3       ,    dim=0 )
   lowercase__, lowercase__, lowercase__:   Union[str, Any]					=      checkpoint[F"""{old_prefix}.qkv.bias"""].chunk(3       ,    dim=0 )

   lowercase__:   List[Any]					=      checkpoint[F"""{old_prefix}.norm.weight"""]
   lowercase__:   str					=      checkpoint[F"""{old_prefix}.norm.bias"""]

   lowercase__:   List[Any]					=      weight_q.squeeze(-1 ).squeeze(-1 )
   lowercase__:   Tuple					=      bias_q.squeeze(-1 ).squeeze(-1 )
   lowercase__:   Tuple					=      weight_k.squeeze(-1 ).squeeze(-1 )
   lowercase__:   Tuple					=      bias_k.squeeze(-1 ).squeeze(-1 )
   lowercase__:   Optional[int]					=      weight_v.squeeze(-1 ).squeeze(-1 )
   lowercase__:   int					=      bias_v.squeeze(-1 ).squeeze(-1 )

   lowercase__:   Tuple					=      (
       checkpoint[F"""{old_prefix}.proj_out.weight"""].squeeze(-1 ).squeeze(-1 )
   )
   lowercase__:   Tuple					=      checkpoint[F"""{old_prefix}.proj_out.bias"""].squeeze(-1 ).squeeze(-1 )

   return new_checkpoint



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase )  ->  Dict:
   lowercase__:   Dict					=      torch.load(__UpperCAmelCase       ,    map_location='''cpu''' )
   lowercase__:   Optional[int]					=      {}

   lowercase__:   Optional[int]					=      checkpoint['''time_embed.0.weight''']
   lowercase__:   Union[str, Any]					=      checkpoint['''time_embed.0.bias''']
   lowercase__:   Union[str, Any]					=      checkpoint['''time_embed.2.weight''']
   lowercase__:   Optional[Any]					=      checkpoint['''time_embed.2.bias''']

   if unet_config["num_class_embeds"] is not None:
      lowercase__:   int					=      checkpoint['''label_emb.weight''']

   lowercase__:   List[Any]					=      checkpoint['''input_blocks.0.0.weight''']
   lowercase__:   str					=      checkpoint['''input_blocks.0.0.bias''']

   lowercase__:   Union[str, Any]					=      unet_config['''down_block_types''']
   lowercase__:   Tuple					=      unet_config['''layers_per_block''']
   lowercase__:   List[Any]					=      unet_config['''attention_head_dim''']
   lowercase__:   List[Any]					=      unet_config['''block_out_channels''']
   lowercase__:   List[str]					=      1
   lowercase__:   Any					=      channels_list[0]

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

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

      if i != len(__UpperCAmelCase ) - 1:
         lowercase__:   str					=      F"""down_blocks.{i}.downsamplers.0"""
         lowercase__:   Any					=      F"""input_blocks.{current_layer}.0"""
         lowercase__:   Union[str, Any]					=      convert_resnet(__UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase )
         current_layer += 1

      lowercase__:   Any					=      current_channels

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

   lowercase__:   List[str]					=      0
   lowercase__:   str					=      unet_config['''up_block_types''']

   for i, layer_type in enumerate(__UpperCAmelCase ):
      if layer_type == "ResnetUpsampleBlock2D":
         for j in range(layers_per_block + 1 ):
            lowercase__:   Tuple					=      F"""up_blocks.{i}.resnets.{j}"""
            lowercase__:   Any					=      F"""output_blocks.{current_layer}.0"""
            lowercase__:   List[str]					=      convert_resnet(__UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    has_skip=__UpperCAmelCase )
            current_layer += 1

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

         if i != len(__UpperCAmelCase ) - 1:
            lowercase__:   Optional[int]					=      F"""up_blocks.{i}.upsamplers.0"""
            lowercase__:   Dict					=      F"""output_blocks.{current_layer-1}.2"""
            lowercase__:   List[Any]					=      convert_resnet(__UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase )

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

   return new_checkpoint


if __name__ == "__main__":
       __A			   = 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.")

       __A			   = parser.parse_args()
       __A			   = strabool(args.class_cond)

       __A			   = os.path.basename(args.unet_path)
       print(f'''Checkpoint: {ckpt_name}''')

       # Get U-Net config
       if "imagenet64" in ckpt_name:
              __A			   = IMAGENET_64_UNET_CONFIG
       elif "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)):
              __A			   = LSUN_256_UNET_CONFIG
       elif "test" in ckpt_name:
              __A			   = TEST_UNET_CONFIG
       else:
              raise ValueError(f'''Checkpoint type {ckpt_name} is not currently supported.''')

       if not args.class_cond:
              __A			   = None

       __A			   = con_pt_to_diffuser(args.unet_path, unet_config)

       __A			   = UNetaDModel(**unet_config)
       image_unet.load_state_dict(converted_unet_ckpt)

       # Get scheduler config
       if "cd" in ckpt_name or "test" in ckpt_name:
              __A			   = CD_SCHEDULER_CONFIG
       elif "ct" in ckpt_name and "imagenet64" in ckpt_name:
              __A			   = 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)):
              __A			   = CT_LSUN_256_SCHEDULER_CONFIG
       else:
              raise ValueError(f'''Checkpoint type {ckpt_name} is not currently supported.''')

       __A			   = CMStochasticIterativeScheduler(**scheduler_config)

       __A			   = ConsistencyModelPipeline(unet=image_unet, scheduler=cm_scheduler)
       consistency_model.save_pretrained(args.dump_path)

"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   if n == 1 or not isinstance(__UpperCAmelCase       ,    __UpperCAmelCase ):
      return 0
   elif n == 2:
      return 1
   else:
      lowercase__:   List[Any]					=      [0, 1]
      for i in range(2       ,    n + 1 ):
         sequence.append(sequence[i - 1] + sequence[i - 2] )

      return sequence[n]



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   lowercase__:   Union[str, Any]					=      0
   lowercase__:   List[Any]					=      2

   while digits < n:
      index += 1
      lowercase__:   Dict					=      len(str(fibonacci(__UpperCAmelCase ) ) )

   return index



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase = 1_0_0_0 )  ->  int:
   return fibonacci_digits_index(__UpperCAmelCase )


if __name__ == "__main__":
       print(solution(int(str(input()).strip())))
