



import argparse
import json

import torch

from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNetaDModel, VQModel





def        __magic_name__			(							lowercase							,     lowercase=1	):







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





def        __magic_name__			(							lowercase							,     lowercase=0	):
   SCREAMING_SNAKE_CASE_:	Any            =[]
   for old_item in old_list:
      SCREAMING_SNAKE_CASE_:	int            =old_item
      SCREAMING_SNAKE_CASE_:	str            =new_item.replace("""block."""							,     """resnets."""	)
      SCREAMING_SNAKE_CASE_:	Any            =new_item.replace("""conv_shorcut"""							,     """conv1"""	)
      SCREAMING_SNAKE_CASE_:	Any            =new_item.replace("""in_shortcut"""							,     """conv_shortcut"""	)
      SCREAMING_SNAKE_CASE_:	Any            =new_item.replace("""temb_proj"""							,     """time_emb_proj"""	)

      SCREAMING_SNAKE_CASE_:	Tuple            =shave_segments(lowercase							,     n_shave_prefix_segments=lowercase	)

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

   return mapping





def        __magic_name__			(							lowercase							,     lowercase=0							,     lowercase=False	):
   SCREAMING_SNAKE_CASE_:	Tuple            =[]
   for old_item in old_list:
      SCREAMING_SNAKE_CASE_:	str            =old_item

      # In `model.mid`, the layer is called `attn`.
      if not in_mid:
         SCREAMING_SNAKE_CASE_:	List[Any]            =new_item.replace("""attn"""							,     """attentions"""	)
      SCREAMING_SNAKE_CASE_:	List[Any]            =new_item.replace(""".k."""							,     """.key."""	)
      SCREAMING_SNAKE_CASE_:	str            =new_item.replace(""".v."""							,     """.value."""	)
      SCREAMING_SNAKE_CASE_:	int            =new_item.replace(""".q."""							,     """.query."""	)

      SCREAMING_SNAKE_CASE_:	Optional[Any]            =new_item.replace("""proj_out"""							,     """proj_attn"""	)
      SCREAMING_SNAKE_CASE_:	Union[str, Any]            =new_item.replace("""norm"""							,     """group_norm"""	)

      SCREAMING_SNAKE_CASE_:	Optional[Any]            =shave_segments(lowercase							,     n_shave_prefix_segments=lowercase	)
      mapping.append({"""old""": old_item, """new""": new_item}	)

   return mapping





def        __magic_name__			(							lowercase							,     lowercase							,     lowercase							,     lowercase=None							,     lowercase=None							,     lowercase=None	):
   assert isinstance(lowercase							,     lowercase	), "Paths should be a list of dicts containing 'old' and 'new' keys."

   if attention_paths_to_split is not None:
      if config is None:
         raise ValueError("""Please specify the config if setting \'attention_paths_to_split\' to \'True\'."""	)

      for path, path_map in attention_paths_to_split.items():
         SCREAMING_SNAKE_CASE_:	Tuple            =old_checkpoint[path]
         SCREAMING_SNAKE_CASE_:	List[Any]            =old_tensor.shape[0] // 3

         SCREAMING_SNAKE_CASE_:	Dict            =(-1, channels) if len(old_tensor.shape	) == 3 else (-1)

         SCREAMING_SNAKE_CASE_:	Tuple            =old_tensor.shape[0] // config.get("""num_head_channels"""							,     1	) // 3

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

         SCREAMING_SNAKE_CASE_:	int            =query.reshape(lowercase	).squeeze()
         SCREAMING_SNAKE_CASE_:	int            =key.reshape(lowercase	).squeeze()
         SCREAMING_SNAKE_CASE_:	Union[str, Any]            =value.reshape(lowercase	).squeeze()

   for path in paths:
      SCREAMING_SNAKE_CASE_:	Dict            =path["""new"""]

      if attention_paths_to_split is not None and new_path in attention_paths_to_split:
         continue

      SCREAMING_SNAKE_CASE_:	List[Any]            =new_path.replace("""down."""							,     """down_blocks."""	)
      SCREAMING_SNAKE_CASE_:	str            =new_path.replace("""up."""							,     """up_blocks."""	)

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

      if "attentions" in new_path:
         SCREAMING_SNAKE_CASE_:	List[Any]            =old_checkpoint[path["""old"""]].squeeze()
      else:
         SCREAMING_SNAKE_CASE_:	List[str]            =old_checkpoint[path["""old"""]]





def        __magic_name__			(							lowercase							,     lowercase	):
   SCREAMING_SNAKE_CASE_:	int            ={}

   SCREAMING_SNAKE_CASE_:	int            =checkpoint["""temb.dense.0.weight"""]
   SCREAMING_SNAKE_CASE_:	str            =checkpoint["""temb.dense.0.bias"""]
   SCREAMING_SNAKE_CASE_:	Optional[int]            =checkpoint["""temb.dense.1.weight"""]
   SCREAMING_SNAKE_CASE_:	Dict            =checkpoint["""temb.dense.1.bias"""]

   SCREAMING_SNAKE_CASE_:	List[Any]            =checkpoint["""norm_out.weight"""]
   SCREAMING_SNAKE_CASE_:	str            =checkpoint["""norm_out.bias"""]

   SCREAMING_SNAKE_CASE_:	Optional[Any]            =checkpoint["""conv_in.weight"""]
   SCREAMING_SNAKE_CASE_:	Any            =checkpoint["""conv_in.bias"""]
   SCREAMING_SNAKE_CASE_:	Dict            =checkpoint["""conv_out.weight"""]
   SCREAMING_SNAKE_CASE_:	Dict            =checkpoint["""conv_out.bias"""]

   SCREAMING_SNAKE_CASE_:	Tuple            =len({""".""".join(layer.split("""."""	)[:2]	) for layer in checkpoint if """down""" in layer}	)
   SCREAMING_SNAKE_CASE_:	Optional[Any]            ={
       layer_id: [key for key in checkpoint if f'''down.{layer_id}''' in key] for layer_id in range(lowercase	)
   }

   SCREAMING_SNAKE_CASE_:	Optional[Any]            =len({""".""".join(layer.split("""."""	)[:2]	) for layer in checkpoint if """up""" in layer}	)
   SCREAMING_SNAKE_CASE_:	Tuple            ={layer_id: [key for key in checkpoint if f'''up.{layer_id}''' in key] for layer_id in range(lowercase	)}

   for i in range(lowercase	):
      SCREAMING_SNAKE_CASE_:	List[Any]            =(i - 1) // (config["""layers_per_block"""] + 1)

      if any("""downsample""" in layer for layer in down_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Any            =checkpoint[
             f'''down.{i}.downsample.op.weight'''
         ]
         SCREAMING_SNAKE_CASE_:	Optional[Any]            =checkpoint[f'''down.{i}.downsample.op.bias''']
      #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.weight'] = checkpoint[f'down.{i}.downsample.conv.weight']
      #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.bias'] = checkpoint[f'down.{i}.downsample.conv.bias']

      if any("""block""" in layer for layer in down_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	List[Any]            =len(
             {""".""".join(shave_segments(lowercase							,     2	).split("""."""	)[:2]	) for layer in down_blocks[i] if """block""" in layer}	)
         SCREAMING_SNAKE_CASE_:	List[str]            ={
             layer_id: [key for key in down_blocks[i] if f'''block.{layer_id}''' in key]
             for layer_id in range(lowercase	)
         }

         if num_blocks > 0:
            for j in range(config["""layers_per_block"""]	):
               SCREAMING_SNAKE_CASE_:	Any            =renew_resnet_paths(blocks[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase	)

      if any("""attn""" in layer for layer in down_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Dict            =len(
             {""".""".join(shave_segments(lowercase							,     2	).split("""."""	)[:2]	) for layer in down_blocks[i] if """attn""" in layer}	)
         SCREAMING_SNAKE_CASE_:	int            ={
             layer_id: [key for key in down_blocks[i] if f'''attn.{layer_id}''' in key]
             for layer_id in range(lowercase	)
         }

         if num_attn > 0:
            for j in range(config["""layers_per_block"""]	):
               SCREAMING_SNAKE_CASE_:	str            =renew_attention_paths(attns[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase							,     config=lowercase	)

   SCREAMING_SNAKE_CASE_:	str            =[key for key in checkpoint if """mid.block_1""" in key]
   SCREAMING_SNAKE_CASE_:	List[Any]            =[key for key in checkpoint if """mid.block_2""" in key]
   SCREAMING_SNAKE_CASE_:	Optional[Any]            =[key for key in checkpoint if """mid.attn_1""" in key]

   # Mid new 2
   SCREAMING_SNAKE_CASE_:	Any            =renew_resnet_paths(lowercase	)
   assign_to_checkpoint(
       lowercase							,     lowercase							,     lowercase							,     additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_1""", """new""": """resnets.0"""}]							,     )

   SCREAMING_SNAKE_CASE_:	List[Any]            =renew_resnet_paths(lowercase	)
   assign_to_checkpoint(
       lowercase							,     lowercase							,     lowercase							,     additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_2""", """new""": """resnets.1"""}]							,     )

   SCREAMING_SNAKE_CASE_:	Optional[int]            =renew_attention_paths(lowercase							,     in_mid=lowercase	)
   assign_to_checkpoint(
       lowercase							,     lowercase							,     lowercase							,     additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """attn_1""", """new""": """attentions.0"""}]							,     )

   for i in range(lowercase	):
      SCREAMING_SNAKE_CASE_:	Tuple            =num_up_blocks - 1 - i

      if any("""upsample""" in layer for layer in up_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	List[Any]            =checkpoint[
             f'''up.{i}.upsample.conv.weight'''
         ]
         SCREAMING_SNAKE_CASE_:	Any            =checkpoint[f'''up.{i}.upsample.conv.bias''']

      if any("""block""" in layer for layer in up_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	str            =len(
             {""".""".join(shave_segments(lowercase							,     2	).split("""."""	)[:2]	) for layer in up_blocks[i] if """block""" in layer}	)
         SCREAMING_SNAKE_CASE_:	Optional[int]            ={
             layer_id: [key for key in up_blocks[i] if f'''block.{layer_id}''' in key] for layer_id in range(lowercase	)
         }

         if num_blocks > 0:
            for j in range(config["""layers_per_block"""] + 1	):
               SCREAMING_SNAKE_CASE_:	List[str]            ={"""old""": f'''up_blocks.{i}''', """new""": f'''up_blocks.{block_id}'''}
               SCREAMING_SNAKE_CASE_:	Tuple            =renew_resnet_paths(blocks[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase							,     additional_replacements=[replace_indices]	)

      if any("""attn""" in layer for layer in up_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Tuple            =len(
             {""".""".join(shave_segments(lowercase							,     2	).split("""."""	)[:2]	) for layer in up_blocks[i] if """attn""" in layer}	)
         SCREAMING_SNAKE_CASE_:	Optional[int]            ={
             layer_id: [key for key in up_blocks[i] if f'''attn.{layer_id}''' in key] for layer_id in range(lowercase	)
         }

         if num_attn > 0:
            for j in range(config["""layers_per_block"""] + 1	):
               SCREAMING_SNAKE_CASE_:	Any            ={"""old""": f'''up_blocks.{i}''', """new""": f'''up_blocks.{block_id}'''}
               SCREAMING_SNAKE_CASE_:	int            =renew_attention_paths(attns[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase							,     additional_replacements=[replace_indices]	)

   SCREAMING_SNAKE_CASE_:	str            ={k.replace("""mid_new_2"""							,     """mid_block"""	): v for k, v in new_checkpoint.items()}
   return new_checkpoint





def        __magic_name__			(							lowercase							,     lowercase	):
   SCREAMING_SNAKE_CASE_:	List[str]            ={}

   SCREAMING_SNAKE_CASE_:	Dict            =checkpoint["""encoder.norm_out.weight"""]
   SCREAMING_SNAKE_CASE_:	int            =checkpoint["""encoder.norm_out.bias"""]

   SCREAMING_SNAKE_CASE_:	Optional[Any]            =checkpoint["""encoder.conv_in.weight"""]
   SCREAMING_SNAKE_CASE_:	List[str]            =checkpoint["""encoder.conv_in.bias"""]
   SCREAMING_SNAKE_CASE_:	Tuple            =checkpoint["""encoder.conv_out.weight"""]
   SCREAMING_SNAKE_CASE_:	Union[str, Any]            =checkpoint["""encoder.conv_out.bias"""]

   SCREAMING_SNAKE_CASE_:	Any            =checkpoint["""decoder.norm_out.weight"""]
   SCREAMING_SNAKE_CASE_:	Optional[Any]            =checkpoint["""decoder.norm_out.bias"""]

   SCREAMING_SNAKE_CASE_:	int            =checkpoint["""decoder.conv_in.weight"""]
   SCREAMING_SNAKE_CASE_:	Any            =checkpoint["""decoder.conv_in.bias"""]
   SCREAMING_SNAKE_CASE_:	List[str]            =checkpoint["""decoder.conv_out.weight"""]
   SCREAMING_SNAKE_CASE_:	Optional[Any]            =checkpoint["""decoder.conv_out.bias"""]

   SCREAMING_SNAKE_CASE_:	int            =len({""".""".join(layer.split("""."""	)[:3]	) for layer in checkpoint if """down""" in layer}	)
   SCREAMING_SNAKE_CASE_:	Optional[Any]            ={
       layer_id: [key for key in checkpoint if f'''down.{layer_id}''' in key] for layer_id in range(lowercase	)
   }

   SCREAMING_SNAKE_CASE_:	Optional[Any]            =len({""".""".join(layer.split("""."""	)[:3]	) for layer in checkpoint if """up""" in layer}	)
   SCREAMING_SNAKE_CASE_:	Union[str, Any]            ={layer_id: [key for key in checkpoint if f'''up.{layer_id}''' in key] for layer_id in range(lowercase	)}

   for i in range(lowercase	):
      SCREAMING_SNAKE_CASE_:	Union[str, Any]            =(i - 1) // (config["""layers_per_block"""] + 1)

      if any("""downsample""" in layer for layer in down_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Optional[int]            =checkpoint[
             f'''encoder.down.{i}.downsample.conv.weight'''
         ]
         SCREAMING_SNAKE_CASE_:	List[Any]            =checkpoint[
             f'''encoder.down.{i}.downsample.conv.bias'''
         ]

      if any("""block""" in layer for layer in down_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Dict            =len(
             {""".""".join(shave_segments(lowercase							,     3	).split("""."""	)[:3]	) for layer in down_blocks[i] if """block""" in layer}	)
         SCREAMING_SNAKE_CASE_:	Tuple            ={
             layer_id: [key for key in down_blocks[i] if f'''block.{layer_id}''' in key]
             for layer_id in range(lowercase	)
         }

         if num_blocks > 0:
            for j in range(config["""layers_per_block"""]	):
               SCREAMING_SNAKE_CASE_:	List[Any]            =renew_resnet_paths(blocks[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase	)

      if any("""attn""" in layer for layer in down_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Optional[int]            =len(
             {""".""".join(shave_segments(lowercase							,     3	).split("""."""	)[:3]	) for layer in down_blocks[i] if """attn""" in layer}	)
         SCREAMING_SNAKE_CASE_:	Optional[Any]            ={
             layer_id: [key for key in down_blocks[i] if f'''attn.{layer_id}''' in key]
             for layer_id in range(lowercase	)
         }

         if num_attn > 0:
            for j in range(config["""layers_per_block"""]	):
               SCREAMING_SNAKE_CASE_:	Dict            =renew_attention_paths(attns[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase							,     config=lowercase	)

   SCREAMING_SNAKE_CASE_:	List[str]            =[key for key in checkpoint if """mid.block_1""" in key]
   SCREAMING_SNAKE_CASE_:	Tuple            =[key for key in checkpoint if """mid.block_2""" in key]
   SCREAMING_SNAKE_CASE_:	int            =[key for key in checkpoint if """mid.attn_1""" in key]

   # Mid new 2
   SCREAMING_SNAKE_CASE_:	List[str]            =renew_resnet_paths(lowercase	)
   assign_to_checkpoint(
       lowercase							,     lowercase							,     lowercase							,     additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_1""", """new""": """resnets.0"""}]							,     )

   SCREAMING_SNAKE_CASE_:	Dict            =renew_resnet_paths(lowercase	)
   assign_to_checkpoint(
       lowercase							,     lowercase							,     lowercase							,     additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """block_2""", """new""": """resnets.1"""}]							,     )

   SCREAMING_SNAKE_CASE_:	Optional[int]            =renew_attention_paths(lowercase							,     in_mid=lowercase	)
   assign_to_checkpoint(
       lowercase							,     lowercase							,     lowercase							,     additional_replacements=[{"""old""": """mid.""", """new""": """mid_new_2."""}, {"""old""": """attn_1""", """new""": """attentions.0"""}]							,     )

   for i in range(lowercase	):
      SCREAMING_SNAKE_CASE_:	Union[str, Any]            =num_up_blocks - 1 - i

      if any("""upsample""" in layer for layer in up_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Tuple            =checkpoint[
             f'''decoder.up.{i}.upsample.conv.weight'''
         ]
         SCREAMING_SNAKE_CASE_:	Tuple            =checkpoint[
             f'''decoder.up.{i}.upsample.conv.bias'''
         ]

      if any("""block""" in layer for layer in up_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	List[Any]            =len(
             {""".""".join(shave_segments(lowercase							,     3	).split("""."""	)[:3]	) for layer in up_blocks[i] if """block""" in layer}	)
         SCREAMING_SNAKE_CASE_:	Optional[Any]            ={
             layer_id: [key for key in up_blocks[i] if f'''block.{layer_id}''' in key] for layer_id in range(lowercase	)
         }

         if num_blocks > 0:
            for j in range(config["""layers_per_block"""] + 1	):
               SCREAMING_SNAKE_CASE_:	List[str]            ={"""old""": f'''up_blocks.{i}''', """new""": f'''up_blocks.{block_id}'''}
               SCREAMING_SNAKE_CASE_:	int            =renew_resnet_paths(blocks[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase							,     additional_replacements=[replace_indices]	)

      if any("""attn""" in layer for layer in up_blocks[i]	):
         SCREAMING_SNAKE_CASE_:	Union[str, Any]            =len(
             {""".""".join(shave_segments(lowercase							,     3	).split("""."""	)[:3]	) for layer in up_blocks[i] if """attn""" in layer}	)
         SCREAMING_SNAKE_CASE_:	List[Any]            ={
             layer_id: [key for key in up_blocks[i] if f'''attn.{layer_id}''' in key] for layer_id in range(lowercase	)
         }

         if num_attn > 0:
            for j in range(config["""layers_per_block"""] + 1	):
               SCREAMING_SNAKE_CASE_:	Optional[int]            ={"""old""": f'''up_blocks.{i}''', """new""": f'''up_blocks.{block_id}'''}
               SCREAMING_SNAKE_CASE_:	List[Any]            =renew_attention_paths(attns[j]	)
               assign_to_checkpoint(lowercase							,     lowercase							,     lowercase							,     additional_replacements=[replace_indices]	)

   SCREAMING_SNAKE_CASE_:	List[Any]            ={k.replace("""mid_new_2"""							,     """mid_block"""	): v for k, v in new_checkpoint.items()}
   SCREAMING_SNAKE_CASE_:	List[Any]            =checkpoint["""quant_conv.weight"""]
   SCREAMING_SNAKE_CASE_:	List[Any]            =checkpoint["""quant_conv.bias"""]
   if "quantize.embedding.weight" in checkpoint:
      SCREAMING_SNAKE_CASE_:	Any            =checkpoint["""quantize.embedding.weight"""]
   SCREAMING_SNAKE_CASE_:	Any            =checkpoint["""post_quant_conv.weight"""]
   SCREAMING_SNAKE_CASE_:	Any            =checkpoint["""post_quant_conv.bias"""]

   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(
       """--config_file""",
       default=None,
       type=str,
       required=True,
       help="""The config json file corresponding to the architecture.""",
   )

   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)

   with open(args.config_file) as f:
      _UpperCAmelCase       =     json.loads(f.read())

   # unet case
   _UpperCAmelCase       =     {key.split(""".""")[0] for key in checkpoint.keys()}
   if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
      _UpperCAmelCase       =     convert_vq_autoenc_checkpoint(checkpoint, config)
   else:
      _UpperCAmelCase       =     convert_ddpm_checkpoint(checkpoint, config)

   if "ddpm" in config:
      del config["ddpm"]

   if config["_class_name"] == "VQModel":
      _UpperCAmelCase       =     VQModel(**config)
      model.load_state_dict(converted_checkpoint)
      model.save_pretrained(args.dump_path)
   elif config["_class_name"] == "AutoencoderKL":
      _UpperCAmelCase       =     AutoencoderKL(**config)
      model.load_state_dict(converted_checkpoint)
      model.save_pretrained(args.dump_path)
   else:
      _UpperCAmelCase       =     UNetaDModel(**config)
      model.load_state_dict(converted_checkpoint)

      _UpperCAmelCase       =     DDPMScheduler.from_config("""/""".join(args.checkpoint_path.split("""/""")[:-1]))

      _UpperCAmelCase       =     DDPMPipeline(unet=model, scheduler=scheduler)
      pipe.save_pretrained(args.dump_path)








"""simple docstring"""
def        __magic_name__			(							lowercase = 1000	):
   SCREAMING_SNAKE_CASE_:	Dict            =0
   SCREAMING_SNAKE_CASE_:	Any            =0
   while 1:
      num += 3
      if num >= n:
         break
      total += num
      num += 2
      if num >= n:
         break
      total += num
      num += 1
      if num >= n:
         break
      total += num
      num += 3
      if num >= n:
         break
      total += num
      num += 1
      if num >= n:
         break
      total += num
      num += 2
      if num >= n:
         break
      total += num
      num += 3
      if num >= n:
         break
      total += num
   return total


if __name__ == "__main__":
   print(f"""{solution() = }""")



