



import argparse
import json

import torch

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



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase=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  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase=0):
					UpperCamelCase_			= []
					for old_item in old_list:
										UpperCamelCase_			= old_item
										UpperCamelCase_			= new_item.replace("block." ,						"resnets.")
										UpperCamelCase_			= new_item.replace("conv_shorcut" ,						"conv1")
										UpperCamelCase_			= new_item.replace("in_shortcut" ,						"conv_shortcut")
										UpperCamelCase_			= new_item.replace("temb_proj" ,						"time_emb_proj")

										UpperCamelCase_			= shave_segments(_lowerCAmelCase ,						n_shave_prefix_segments=_lowerCAmelCase)

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

					return mapping



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase=0 ,						_lowerCAmelCase=False):
					UpperCamelCase_			= []
					for old_item in old_list:
										UpperCamelCase_			= old_item

										# In `model.mid`, the layer is called `attn`.
										if not in_mid:
															UpperCamelCase_			= new_item.replace("attn" ,						"attentions")
										UpperCamelCase_			= new_item.replace(".k." ,						".key.")
										UpperCamelCase_			= new_item.replace(".v." ,						".value.")
										UpperCamelCase_			= new_item.replace(".q." ,						".query.")

										UpperCamelCase_			= new_item.replace("proj_out" ,						"proj_attn")
										UpperCamelCase_			= new_item.replace("norm" ,						"group_norm")

										UpperCamelCase_			= shave_segments(_lowerCAmelCase ,						n_shave_prefix_segments=_lowerCAmelCase)
										mapping.append({"old": old_item, "new": new_item})

					return mapping



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase=None ,						_lowerCAmelCase=None ,						_lowerCAmelCase=None):
					assert isinstance(_lowerCAmelCase ,						_lowerCAmelCase), "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():
															UpperCamelCase_			= old_checkpoint[path]
															UpperCamelCase_			= old_tensor.shape[0] // 3

															UpperCamelCase_			= (-1, channels) if len(old_tensor.shape) == 3 else (-1)

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

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

															UpperCamelCase_			= query.reshape(_lowerCAmelCase).squeeze()
															UpperCamelCase_			= key.reshape(_lowerCAmelCase).squeeze()
															UpperCamelCase_			= value.reshape(_lowerCAmelCase).squeeze()

					for path in paths:
										UpperCamelCase_			= path["new"]

										if attention_paths_to_split is not None and new_path in attention_paths_to_split:
															continue

										UpperCamelCase_			= new_path.replace("down." ,						"down_blocks.")
										UpperCamelCase_			= new_path.replace("up." ,						"up_blocks.")

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

										if "attentions" in new_path:
															UpperCamelCase_			= old_checkpoint[path["old"]].squeeze()
										else:
															UpperCamelCase_			= old_checkpoint[path["old"]]



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					UpperCamelCase_			= {}

					UpperCamelCase_			= checkpoint["temb.dense.0.weight"]
					UpperCamelCase_			= checkpoint["temb.dense.0.bias"]
					UpperCamelCase_			= checkpoint["temb.dense.1.weight"]
					UpperCamelCase_			= checkpoint["temb.dense.1.bias"]

					UpperCamelCase_			= checkpoint["norm_out.weight"]
					UpperCamelCase_			= checkpoint["norm_out.bias"]

					UpperCamelCase_			= checkpoint["conv_in.weight"]
					UpperCamelCase_			= checkpoint["conv_in.bias"]
					UpperCamelCase_			= checkpoint["conv_out.weight"]
					UpperCamelCase_			= checkpoint["conv_out.bias"]

					UpperCamelCase_			= len({".".join(layer.split(".")[:2]) for layer in checkpoint if "down" in layer})
					UpperCamelCase_			= {
					    layer_id: [key for key in checkpoint if f"""down.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)
					}

					UpperCamelCase_			= len({".".join(layer.split(".")[:2]) for layer in checkpoint if "up" in layer})
					UpperCamelCase_			= {layer_id: [key for key in checkpoint if f"""up.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)}

					for i in range(_lowerCAmelCase):
										UpperCamelCase_			= (i - 1) // (config["layers_per_block"] + 1)

										if any("downsample" in layer for layer in down_blocks[i]):
															UpperCamelCase_			= checkpoint[
															    f"""down.{i}.downsample.op.weight"""
															]
															UpperCamelCase_			= 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]):
															UpperCamelCase_			= len(
															    {".".join(shave_segments(_lowerCAmelCase ,						2).split(".")[:2]) for layer in down_blocks[i] if "block" in layer})
															UpperCamelCase_			= {
															    layer_id: [key for key in down_blocks[i] if f"""block.{layer_id}""" in key]
															    for layer_id in range(_lowerCAmelCase)
															}

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

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

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

					UpperCamelCase_			= [key for key in checkpoint if "mid.block_1" in key]
					UpperCamelCase_			= [key for key in checkpoint if "mid.block_2" in key]
					UpperCamelCase_			= [key for key in checkpoint if "mid.attn_1" in key]

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

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

					UpperCamelCase_			= renew_attention_paths(_lowerCAmelCase ,						in_mid=_lowerCAmelCase)
					assign_to_checkpoint(
					    _lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase ,						additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "attn_1", "new": "attentions.0"}] ,						)

					for i in range(_lowerCAmelCase):
										UpperCamelCase_			= num_up_blocks - 1 - i

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

										if any("block" in layer for layer in up_blocks[i]):
															UpperCamelCase_			= len(
															    {".".join(shave_segments(_lowerCAmelCase ,						2).split(".")[:2]) for layer in up_blocks[i] if "block" in layer})
															UpperCamelCase_			= {
															    layer_id: [key for key in up_blocks[i] if f"""block.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)
															}

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

										if any("attn" in layer for layer in up_blocks[i]):
															UpperCamelCase_			= len(
															    {".".join(shave_segments(_lowerCAmelCase ,						2).split(".")[:2]) for layer in up_blocks[i] if "attn" in layer})
															UpperCamelCase_			= {
															    layer_id: [key for key in up_blocks[i] if f"""attn.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)
															}

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

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



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					UpperCamelCase_			= {}

					UpperCamelCase_			= checkpoint["encoder.norm_out.weight"]
					UpperCamelCase_			= checkpoint["encoder.norm_out.bias"]

					UpperCamelCase_			= checkpoint["encoder.conv_in.weight"]
					UpperCamelCase_			= checkpoint["encoder.conv_in.bias"]
					UpperCamelCase_			= checkpoint["encoder.conv_out.weight"]
					UpperCamelCase_			= checkpoint["encoder.conv_out.bias"]

					UpperCamelCase_			= checkpoint["decoder.norm_out.weight"]
					UpperCamelCase_			= checkpoint["decoder.norm_out.bias"]

					UpperCamelCase_			= checkpoint["decoder.conv_in.weight"]
					UpperCamelCase_			= checkpoint["decoder.conv_in.bias"]
					UpperCamelCase_			= checkpoint["decoder.conv_out.weight"]
					UpperCamelCase_			= checkpoint["decoder.conv_out.bias"]

					UpperCamelCase_			= len({".".join(layer.split(".")[:3]) for layer in checkpoint if "down" in layer})
					UpperCamelCase_			= {
					    layer_id: [key for key in checkpoint if f"""down.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)
					}

					UpperCamelCase_			= len({".".join(layer.split(".")[:3]) for layer in checkpoint if "up" in layer})
					UpperCamelCase_			= {layer_id: [key for key in checkpoint if f"""up.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)}

					for i in range(_lowerCAmelCase):
										UpperCamelCase_			= (i - 1) // (config["layers_per_block"] + 1)

										if any("downsample" in layer for layer in down_blocks[i]):
															UpperCamelCase_			= checkpoint[
															    f"""encoder.down.{i}.downsample.conv.weight"""
															]
															UpperCamelCase_			= checkpoint[
															    f"""encoder.down.{i}.downsample.conv.bias"""
															]

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

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

										if any("attn" in layer for layer in down_blocks[i]):
															UpperCamelCase_			= len(
															    {".".join(shave_segments(_lowerCAmelCase ,						3).split(".")[:3]) for layer in down_blocks[i] if "attn" in layer})
															UpperCamelCase_			= {
															    layer_id: [key for key in down_blocks[i] if f"""attn.{layer_id}""" in key]
															    for layer_id in range(_lowerCAmelCase)
															}

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

					UpperCamelCase_			= [key for key in checkpoint if "mid.block_1" in key]
					UpperCamelCase_			= [key for key in checkpoint if "mid.block_2" in key]
					UpperCamelCase_			= [key for key in checkpoint if "mid.attn_1" in key]

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

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

					UpperCamelCase_			= renew_attention_paths(_lowerCAmelCase ,						in_mid=_lowerCAmelCase)
					assign_to_checkpoint(
					    _lowerCAmelCase ,						_lowerCAmelCase ,						_lowerCAmelCase ,						additional_replacements=[{"old": "mid.", "new": "mid_new_2."}, {"old": "attn_1", "new": "attentions.0"}] ,						)

					for i in range(_lowerCAmelCase):
										UpperCamelCase_			= num_up_blocks - 1 - i

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

										if any("block" in layer for layer in up_blocks[i]):
															UpperCamelCase_			= len(
															    {".".join(shave_segments(_lowerCAmelCase ,						3).split(".")[:3]) for layer in up_blocks[i] if "block" in layer})
															UpperCamelCase_			= {
															    layer_id: [key for key in up_blocks[i] if f"""block.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)
															}

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

										if any("attn" in layer for layer in up_blocks[i]):
															UpperCamelCase_			= len(
															    {".".join(shave_segments(_lowerCAmelCase ,						3).split(".")[:3]) for layer in up_blocks[i] if "attn" in layer})
															UpperCamelCase_			= {
															    layer_id: [key for key in up_blocks[i] if f"""attn.{layer_id}""" in key] for layer_id in range(_lowerCAmelCase)
															}

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

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

					return new_checkpoint


if __name__ == "__main__":
	UpperCAmelCase :				Any							=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 :				Optional[int]							=parser.parse_args()
	UpperCAmelCase :				Tuple							=torch.load(args.checkpoint_path)

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

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

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

	if config["_class_name"] == "VQModel":
		UpperCAmelCase :				Union[str, Any]							=VQModel(**config)
		model.load_state_dict(converted_checkpoint)
		model.save_pretrained(args.dump_path)
	elif config["_class_name"] == "AutoencoderKL":
		UpperCAmelCase :				int							=AutoencoderKL(**config)
		model.load_state_dict(converted_checkpoint)
		model.save_pretrained(args.dump_path)
	else:
		UpperCAmelCase :				Dict							=UNetaDModel(**config)
		model.load_state_dict(converted_checkpoint)

		UpperCAmelCase :				Union[str, Any]							=DDPMScheduler.from_config("""/""".join(args.checkpoint_path.split("""/""")[:-1]))

		UpperCAmelCase :				int							=DDPMPipeline(unet=model, scheduler=scheduler)
		pipe.save_pretrained(args.dump_path)


"""simple docstring"""

UpperCamelCase      :							int          =					1_0**8






def 				A		(							snake_case :int						) ->      bool:
 if n % 1_0 == 0:
  return False
 __UpperCamelCase							    =			str(snake_case						)
 return s == s[::-1]






def 				A		(							) ->      int:
 __UpperCamelCase							    =			set()
 __UpperCamelCase							    =			1
 __UpperCamelCase							    =			5
 while sum_squares < LIMIT:
  __UpperCamelCase							    =			first_square + 1
  while sum_squares < LIMIT:
   if is_palindrome(snake_case						):
    answer.add(snake_case						)
   last_square += 1
   sum_squares += last_square**2
  first_square += 1
  __UpperCamelCase							    =			first_square**2 + (first_square + 1) ** 2

 return sum(snake_case						)


if __name__ == "__main__":
      print(solution())



