






"""simple docstring"""





import argparse

import torch

from diffusers import UNetaDConditionModel






def 							A(    snake_case_		,  snake_case_		,  snake_case_		,  snake_case_=None		,  snake_case_=None		,  snake_case_=None						):
       """simple docstring"""





       assert isinstance(snake_case_		,  snake_case_						), "Paths should be a list of dicts containing 'old' and 'new' keys."

       # Splits the attention layers into three variables.
       if attention_paths_to_split is not None:
              for path, path_map in attention_paths_to_split.items():
                     lowercase__:							str         =     old_checkpoint[path]
                     lowercase__:							int         =     old_tensor.shape[0] // 3

                     lowercase__:							Any         =     (-1, channels) if len(old_tensor.shape						) == 3 else (-1)

                     lowercase__:							Optional[Any]         =     old_tensor.shape[0] // config["num_head_channels"] // 3

                     lowercase__:							Any         =     old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]						)
                     lowercase__    ,      lowercase__    ,      lowercase__:							Dict         =     old_tensor.split(channels // num_heads		,  dim=1						)

                     lowercase__:							int         =     query.reshape(snake_case_						)
                     lowercase__:							Union[str, Any]         =     key.reshape(snake_case_						)
                     lowercase__:							List[Any]         =     value.reshape(snake_case_						)

       for path in paths:
              lowercase__:							Union[str, Any]         =     path["new"]

              # These have already been assigned
              if attention_paths_to_split is not None and new_path in attention_paths_to_split:
                     continue

              if additional_replacements is not None:
                     for replacement in additional_replacements:
                            lowercase__:							Optional[int]         =     new_path.replace(replacement["old"]		,  replacement["new"]						)

        # proj_attn.weight has to be converted from conv 1D to linear
              lowercase__:							Any         =     old_checkpoint[path["old"]]
              lowercase__:							Optional[int]         =     ["proj_attn.weight"]
              lowercase__:							Any         =     ["proj_out.weight", "proj_in.weight"]
              if any(k in new_path for k in names						):
                     lowercase__:							Any         =     weight[:, :, 0]
              elif any(k in new_path for k in names_a						) and len(weight.shape						) > 2 and ".attentions." not in new_path:
                     lowercase__:							Union[str, Any]         =     weight[:, :, 0]
              else:
                     lowercase__:							List[Any]         =     weight






def 							A(    snake_case_		,  snake_case_=0						):
       """simple docstring"""





       lowercase__:							List[str]         =     []
       for old_item in old_list:
              lowercase__:							Optional[int]         =     old_item

              #         new_item = new_item.replace('norm.weight', 'group_norm.weight')
              #         new_item = new_item.replace('norm.bias', 'group_norm.bias')

              #         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
              #         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

              #         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

              mapping.append({"old": old_item, "new": new_item}						)

       return mapping






def 							A(    snake_case_		,  snake_case_=1						):
       """simple docstring"""





       if n_shave_prefix_segments >= 0:
              return ".".join(path.split("."						)[n_shave_prefix_segments:]						)
       else:
              return ".".join(path.split("."						)[:n_shave_prefix_segments]						)






def 							A(    snake_case_		,  snake_case_=0						):
       """simple docstring"""





       lowercase__:							Dict         =     []
       for old_item in old_list:
              mapping.append({"old": old_item, "new": old_item}						)

       return mapping






def 							A(    snake_case_		,  snake_case_=0						):
       """simple docstring"""





       lowercase__:							str         =     []
       for old_item in old_list:
              lowercase__:							Union[str, Any]         =     old_item.replace("in_layers.0"		,  "norm1"						)
              lowercase__:							Optional[Any]         =     new_item.replace("in_layers.2"		,  "conv1"						)

              lowercase__:							Optional[Any]         =     new_item.replace("out_layers.0"		,  "norm2"						)
              lowercase__:							List[str]         =     new_item.replace("out_layers.3"		,  "conv2"						)

              lowercase__:							Optional[int]         =     new_item.replace("emb_layers.1"		,  "time_emb_proj"						)
              lowercase__:							Tuple         =     new_item.replace("skip_connection"		,  "conv_shortcut"						)

              lowercase__:							List[str]         =     shave_segments(snake_case_		,  n_shave_prefix_segments=snake_case_						)

              if "temopral_conv" not in old_item:
                     mapping.append({"old": old_item, "new": new_item}						)

       return mapping






def 							A(    snake_case_		,  snake_case_		,  snake_case_=None		,  snake_case_=False						):
       """simple docstring"""





       lowercase__:							List[Any]         =     {}
       lowercase__:							Optional[Any]         =     list(checkpoint.keys()						)

       lowercase__:							int         =     "model.diffusion_model."

       # at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
       if sum(k.startswith("model_ema"						) for k in keys						) > 100 and extract_ema:
              print(F"""Checkpoint {path} has both EMA and non-EMA weights."""						)
              print(
                  "In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"
                  " weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag."						)
              for key in keys:
                     if key.startswith("model.diffusion_model"						):
                            lowercase__:							Optional[int]         =     "model_ema." + "".join(key.split("."						)[1:]						)
                            lowercase__:							Any         =     checkpoint.pop(snake_case_						)
       else:
              if sum(k.startswith("model_ema"						) for k in keys						) > 100:
                     print(
                         "In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"
                         " weights (usually better for inference), please make sure to add the `--extract_ema` flag."						)

              for key in keys:
                     lowercase__:							Optional[int]         =     checkpoint.pop(snake_case_						)

       lowercase__:							List[str]         =     {}

       lowercase__:							str         =     unet_state_dict["time_embed.0.weight"]
       lowercase__:							List[Any]         =     unet_state_dict["time_embed.0.bias"]
       lowercase__:							Tuple         =     unet_state_dict["time_embed.2.weight"]
       lowercase__:							Union[str, Any]         =     unet_state_dict["time_embed.2.bias"]

       if config["class_embed_type"] is None:
              # No parameters to port
              ...
       elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
              lowercase__:							int         =     unet_state_dict["label_emb.0.0.weight"]
              lowercase__:							Tuple         =     unet_state_dict["label_emb.0.0.bias"]
              lowercase__:							List[str]         =     unet_state_dict["label_emb.0.2.weight"]
              lowercase__:							str         =     unet_state_dict["label_emb.0.2.bias"]
       else:
              raise NotImplementedError(F"""Not implemented `class_embed_type`: {config['class_embed_type']}"""						)

       lowercase__:							str         =     unet_state_dict["input_blocks.0.0.weight"]
       lowercase__:							Optional[int]         =     unet_state_dict["input_blocks.0.0.bias"]

       lowercase__:							List[str]         =     [v for v in unet_state_dict if v.startswith("input_blocks.0.1"						)]
       lowercase__:							Optional[int]         =     renew_attention_paths(snake_case_						)
       lowercase__:							List[str]         =     {"old": "input_blocks.0.1", "new": "transformer_in"}
       assign_to_checkpoint(snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

       lowercase__:							Tuple         =     unet_state_dict["out.0.weight"]
       lowercase__:							List[str]         =     unet_state_dict["out.0.bias"]
       lowercase__:							Union[str, Any]         =     unet_state_dict["out.2.weight"]
       lowercase__:							Tuple         =     unet_state_dict["out.2.bias"]

       # Retrieves the keys for the input blocks only
       lowercase__:							Tuple         =     len({".".join(layer.split("."						)[:2]						) for layer in unet_state_dict if "input_blocks" in layer}						)
       lowercase__:							List[Any]         =     {
           layer_id: [key for key in unet_state_dict if F"""input_blocks.{layer_id}""" in key]
           for layer_id in range(snake_case_						)
       }

       # Retrieves the keys for the middle blocks only
       lowercase__:							List[Any]         =     len({".".join(layer.split("."						)[:2]						) for layer in unet_state_dict if "middle_block" in layer}						)
       lowercase__:							Union[str, Any]         =     {
           layer_id: [key for key in unet_state_dict if F"""middle_block.{layer_id}""" in key]
           for layer_id in range(snake_case_						)
       }

       # Retrieves the keys for the output blocks only
       lowercase__:							Tuple         =     len({".".join(layer.split("."						)[:2]						) for layer in unet_state_dict if "output_blocks" in layer}						)
       lowercase__:							List[str]         =     {
           layer_id: [key for key in unet_state_dict if F"""output_blocks.{layer_id}""" in key]
           for layer_id in range(snake_case_						)
       }

       for i in range(1		,  snake_case_						):
              lowercase__:							List[Any]         =     (i - 1) // (config["layers_per_block"] + 1)
              lowercase__:							int         =     (i - 1) % (config["layers_per_block"] + 1)

              lowercase__:							Optional[int]         =     [
                  key for key in input_blocks[i] if F"""input_blocks.{i}.0""" in key and F"""input_blocks.{i}.0.op""" not in key
              ]
              lowercase__:							Tuple         =     [key for key in input_blocks[i] if F"""input_blocks.{i}.1""" in key]
              lowercase__:							int         =     [key for key in input_blocks[i] if F"""input_blocks.{i}.2""" in key]

              if F"""input_blocks.{i}.op.weight""" in unet_state_dict:
                     lowercase__:							Optional[int]         =     unet_state_dict.pop(
                         F"""input_blocks.{i}.op.weight"""						)
                     lowercase__:							Optional[int]         =     unet_state_dict.pop(
                         F"""input_blocks.{i}.op.bias"""						)

              lowercase__:							Optional[Any]         =     renew_resnet_paths(snake_case_						)
              lowercase__:							Optional[int]         =     {"old": F"""input_blocks.{i}.0""", "new": F"""down_blocks.{block_id}.resnets.{layer_in_block_id}"""}
              assign_to_checkpoint(
                  snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

              lowercase__:							Union[str, Any]         =     [key for key in resnets if "temopral_conv" in key]
              lowercase__:							List[str]         =     renew_temp_conv_paths(snake_case_						)
              lowercase__:							Tuple         =     {
                  "old": F"""input_blocks.{i}.0.temopral_conv""",
                  "new": F"""down_blocks.{block_id}.temp_convs.{layer_in_block_id}""",
              }
              assign_to_checkpoint(
                  snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

              if len(snake_case_						):
                     lowercase__:							Optional[Any]         =     renew_attention_paths(snake_case_						)
                     lowercase__:							Optional[Any]         =     {"old": F"""input_blocks.{i}.1""", "new": F"""down_blocks.{block_id}.attentions.{layer_in_block_id}"""}
                     assign_to_checkpoint(
                         snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

              if len(snake_case_						):
                     lowercase__:							Dict         =     renew_attention_paths(snake_case_						)
                     lowercase__:							str         =     {
                         "old": F"""input_blocks.{i}.2""",
                         "new": F"""down_blocks.{block_id}.temp_attentions.{layer_in_block_id}""",
                     }
                     assign_to_checkpoint(
                         snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

       lowercase__:							List[str]         =     middle_blocks[0]
       lowercase__:							str         =     [key for key in resnet_a if "temopral_conv" in key]
       lowercase__:							List[Any]         =     middle_blocks[1]
       lowercase__:							List[str]         =     middle_blocks[2]
       lowercase__:							int         =     middle_blocks[3]
       lowercase__:							Tuple         =     [key for key in resnet_a if "temopral_conv" in key]

       lowercase__:							Optional[Any]         =     renew_resnet_paths(snake_case_						)
       lowercase__:							List[str]         =     {"old": "middle_block.0", "new": "mid_block.resnets.0"}
       assign_to_checkpoint(
           snake_case_		,  snake_case_		,  snake_case_		,  config=snake_case_		,  additional_replacements=[meta_path]						)

       lowercase__:							Tuple         =     renew_temp_conv_paths(snake_case_						)
       lowercase__:							List[Any]         =     {"old": "middle_block.0.temopral_conv", "new": "mid_block.temp_convs.0"}
       assign_to_checkpoint(
           snake_case_		,  snake_case_		,  snake_case_		,  config=snake_case_		,  additional_replacements=[meta_path]						)

       lowercase__:							Tuple         =     renew_resnet_paths(snake_case_						)
       lowercase__:							Any         =     {"old": "middle_block.3", "new": "mid_block.resnets.1"}
       assign_to_checkpoint(
           snake_case_		,  snake_case_		,  snake_case_		,  config=snake_case_		,  additional_replacements=[meta_path]						)

       lowercase__:							List[Any]         =     renew_temp_conv_paths(snake_case_						)
       lowercase__:							Union[str, Any]         =     {"old": "middle_block.3.temopral_conv", "new": "mid_block.temp_convs.1"}
       assign_to_checkpoint(
           snake_case_		,  snake_case_		,  snake_case_		,  config=snake_case_		,  additional_replacements=[meta_path]						)

       lowercase__:							Tuple         =     renew_attention_paths(snake_case_						)
       lowercase__:							str         =     {"old": "middle_block.1", "new": "mid_block.attentions.0"}
       assign_to_checkpoint(
           snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

       lowercase__:							Any         =     renew_attention_paths(snake_case_						)
       lowercase__:							Any         =     {"old": "middle_block.2", "new": "mid_block.temp_attentions.0"}
       assign_to_checkpoint(
           snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

       for i in range(snake_case_						):
              lowercase__:							int         =     i // (config["layers_per_block"] + 1)
              lowercase__:							Tuple         =     i % (config["layers_per_block"] + 1)
              lowercase__:							Optional[int]         =     [shave_segments(snake_case_		,  2						) for name in output_blocks[i]]
              lowercase__:							Any         =     {}

              for layer in output_block_layers:
                     lowercase__    ,      lowercase__:							str         =     layer.split("."						)[0], shave_segments(snake_case_		,  1						)
                     if layer_id in output_block_list:
                            output_block_list[layer_id].append(snake_case_						)
                     else:
                            lowercase__:							Union[str, Any]         =     [layer_name]

              if len(snake_case_						) > 1:
                     lowercase__:							Tuple         =     [key for key in output_blocks[i] if F"""output_blocks.{i}.0""" in key]
                     lowercase__:							Dict         =     [key for key in output_blocks[i] if F"""output_blocks.{i}.1""" in key]
                     lowercase__:							int         =     [key for key in output_blocks[i] if F"""output_blocks.{i}.2""" in key]

                     lowercase__:							Tuple         =     renew_resnet_paths(snake_case_						)
                     lowercase__:							int         =     renew_resnet_paths(snake_case_						)

                     lowercase__:							List[Any]         =     {"old": F"""output_blocks.{i}.0""", "new": F"""up_blocks.{block_id}.resnets.{layer_in_block_id}"""}
                     assign_to_checkpoint(
                         snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

                     lowercase__:							Dict         =     [key for key in resnets if "temopral_conv" in key]
                     lowercase__:							Dict         =     renew_temp_conv_paths(snake_case_						)
                     lowercase__:							Any         =     {
                         "old": F"""output_blocks.{i}.0.temopral_conv""",
                         "new": F"""up_blocks.{block_id}.temp_convs.{layer_in_block_id}""",
                     }
                     assign_to_checkpoint(
                         snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

                     lowercase__:							Any         =     {k: sorted(snake_case_						) for k, v in output_block_list.items()}
                     if ["conv.bias", "conv.weight"] in output_block_list.values():
                            lowercase__:							Dict         =     list(output_block_list.values()						).index(["conv.bias", "conv.weight"]						)
                            lowercase__:							Optional[int]         =     unet_state_dict[
                                F"""output_blocks.{i}.{index}.conv.weight"""
                            ]
                            lowercase__:							Optional[Any]         =     unet_state_dict[
                                F"""output_blocks.{i}.{index}.conv.bias"""
                            ]

                            # Clear attentions as they have been attributed above.
                            if len(snake_case_						) == 2:
                                   lowercase__:							Dict         =     []

                     if len(snake_case_						):
                            lowercase__:							List[Any]         =     renew_attention_paths(snake_case_						)
                            lowercase__:							Dict         =     {
                                "old": F"""output_blocks.{i}.1""",
                                "new": F"""up_blocks.{block_id}.attentions.{layer_in_block_id}""",
                            }
                            assign_to_checkpoint(
                                snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)

                     if len(snake_case_						):
                            lowercase__:							Dict         =     renew_attention_paths(snake_case_						)
                            lowercase__:							Union[str, Any]         =     {
                                "old": F"""output_blocks.{i}.2""",
                                "new": F"""up_blocks.{block_id}.temp_attentions.{layer_in_block_id}""",
                            }
                            assign_to_checkpoint(
                                snake_case_		,  snake_case_		,  snake_case_		,  additional_replacements=[meta_path]		,  config=snake_case_						)
              else:
                     lowercase__:							Dict         =     renew_resnet_paths(snake_case_		,  n_shave_prefix_segments=1						)
                     for path in resnet_0_paths:
                            lowercase__:							Union[str, Any]         =     ".".join(["output_blocks", str(snake_case_						), path["old"]]						)
                            lowercase__:							Tuple         =     ".".join(["up_blocks", str(snake_case_						), "resnets", str(snake_case_						), path["new"]]						)
                            lowercase__:							Tuple         =     unet_state_dict[old_path]

                     lowercase__:							Optional[Any]         =     [l for l in output_block_layers if "temopral_conv" in l]
                     for path in temopral_conv_paths:
                            lowercase__:							Tuple         =     path.split("temopral_conv."						)[-1]
                            lowercase__:							List[Any]         =     ".".join(["output_blocks", str(snake_case_						), str(snake_case_						), "temopral_conv", pruned_path]						)
                            lowercase__:							int         =     ".".join(["up_blocks", str(snake_case_						), "temp_convs", str(snake_case_						), pruned_path]						)
                            lowercase__:							int         =     unet_state_dict[old_path]

       return new_checkpoint


if __name__ == "__main__":
  UpperCamelCase					=     argparse.ArgumentParser()

  parser.add_argument(
      """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
  )
  parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
  UpperCamelCase					=     parser.parse_args()

  UpperCamelCase					=     torch.load(args.checkpoint_path, map_location="""cpu""")
  UpperCamelCase					=     UNetaDConditionModel()

  UpperCamelCase					=     convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

  UpperCamelCase					=     set(unet.state_dict().keys()) - set(converted_ckpt.keys())
  UpperCamelCase					=     set(converted_ckpt.keys()) - set(unet.state_dict().keys())

  assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

  # load state_dict
  unet.load_state_dict(converted_ckpt)

  unet.save_pretrained(args.dump_path)

  # -- finish converting the unet --











from math import floor, sqrt





def 	__snake_case      (     _UpperCAmelCase							):
    __a					=							0.0
    __a					=							1.0
    __a					=							int(sqrt(_UpperCAmelCase							)							)
    __a					=							root
    __a					=							0
    while integer_part != 2 * root:
        __a					=							denominator * integer_part - numerator
        __a					=							(n - numerator**2) / denominator
        __a					=							int((root + numerator) / denominator							)
        period += 1
    return period





def 	__snake_case      (     _UpperCAmelCase = 10000							):
    __a					=							0
    for i in range(2  ,					n + 1							):
        __a					=							sqrt(_UpperCAmelCase							)
        if sr - floor(_UpperCAmelCase							) != 0 and continuous_fraction_period(_UpperCAmelCase							) % 2 == 1:
            count_odd_periods += 1
    return count_odd_periods


if __name__ == "__main__":
 print(f'{solution(int(input().strip()))}')





