






"""simple docstring"""


import argparse
import json

import torch

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




def 					a			(  UpperCamelCase_				:					Optional[Any]  ,						UpperCamelCase_				:					Optional[Any]=1		)	->		Dict:
 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			(  UpperCamelCase_				:					int  ,						UpperCamelCase_				:					Optional[Any]=0		)	->		List[str]:
 __A						:							Dict      =						[]
 for old_item in old_list:
  __A						:							str      =						old_item
  __A						:							str      =						new_item.replace('block.'  ,						'resnets.'		)
  __A						:							Optional[Any]      =						new_item.replace('conv_shorcut'  ,						'conv1'		)
  __A						:							Optional[Any]      =						new_item.replace('in_shortcut'  ,						'conv_shortcut'		)
  __A						:							int      =						new_item.replace('temb_proj'  ,						'time_emb_proj'		)

  __A						:							int      =						shave_segments(UpperCamelCase_  ,						n_shave_prefix_segments=UpperCamelCase_		)

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

 return mapping




def 					a			(  UpperCamelCase_				:					Tuple  ,						UpperCamelCase_				:					List[Any]=0  ,						UpperCamelCase_				:					List[str]=False		)	->		int:
 __A						:							int      =						[]
 for old_item in old_list:
  __A						:							Any      =						old_item

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

  __A						:							Dict      =						new_item.replace('proj_out'  ,						'proj_attn'		)
  __A						:							str      =						new_item.replace('norm'  ,						'group_norm'		)

  __A						:							int      =						shave_segments(UpperCamelCase_  ,						n_shave_prefix_segments=UpperCamelCase_		)
  mapping.append({'old': old_item, 'new': new_item}		)

 return mapping




def 					a			(  UpperCamelCase_				:					List[str]  ,						UpperCamelCase_				:					Optional[Any]  ,						UpperCamelCase_				:					Union[str, Any]  ,						UpperCamelCase_				:					Optional[int]=None  ,						UpperCamelCase_				:					str=None  ,						UpperCamelCase_				:					int=None		)	->		int:
 assert isinstance(UpperCamelCase_  ,						UpperCamelCase_		), "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():
   __A						:							Union[str, Any]      =						old_checkpoint[path]
   __A						:							List[str]      =						old_tensor.shape[0] // 3

   __A						:							Union[str, Any]      =						(-1, channels) if len(old_tensor.shape		) == 3 else (-1)

   __A						:							Optional[int]      =						old_tensor.shape[0] // config.get('num_head_channels'  ,						1		) // 3

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

   __A						:							Dict      =						query.reshape(UpperCamelCase_		).squeeze()
   __A						:							int      =						key.reshape(UpperCamelCase_		).squeeze()
   __A						:							Union[str, Any]      =						value.reshape(UpperCamelCase_		).squeeze()

 for path in paths:
  __A						:							Any      =						path['new']

  if attention_paths_to_split is not None and new_path in attention_paths_to_split:
   continue

  __A						:							Dict      =						new_path.replace('down.'  ,						'down_blocks.'		)
  __A						:							List[Any]      =						new_path.replace('up.'  ,						'up_blocks.'		)

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

  if "attentions" in new_path:
   __A						:							Union[str, Any]      =						old_checkpoint[path['old']].squeeze()
  else:
   __A						:							Dict      =						old_checkpoint[path['old']]




def 					a			(  UpperCamelCase_				:					str  ,						UpperCamelCase_				:					Union[str, Any]		)	->		List[str]:
 __A						:							List[str]      =						{}

 __A						:							Optional[Any]      =						checkpoint['temb.dense.0.weight']
 __A						:							List[Any]      =						checkpoint['temb.dense.0.bias']
 __A						:							Optional[int]      =						checkpoint['temb.dense.1.weight']
 __A						:							List[Any]      =						checkpoint['temb.dense.1.bias']

 __A						:							Optional[Any]      =						checkpoint['norm_out.weight']
 __A						:							List[Any]      =						checkpoint['norm_out.bias']

 __A						:							str      =						checkpoint['conv_in.weight']
 __A						:							Optional[Any]      =						checkpoint['conv_in.bias']
 __A						:							int      =						checkpoint['conv_out.weight']
 __A						:							Tuple      =						checkpoint['conv_out.bias']

 __A						:							int      =						len({'.'.join(layer.split('.'		)[:2]		) for layer in checkpoint if 'down' in layer}		)
 __A						:							Dict      =						{
     layer_id: [key for key in checkpoint if F"down.{layer_id}" in key] for layer_id in range(UpperCamelCase_		)
 }

 __A						:							List[str]      =						len({'.'.join(layer.split('.'		)[:2]		) for layer in checkpoint if 'up' in layer}		)
 __A						:							List[Any]      =						{layer_id: [key for key in checkpoint if F"up.{layer_id}" in key] for layer_id in range(UpperCamelCase_		)}

 for i in range(UpperCamelCase_		):
  __A						:							Optional[Any]      =						(i - 1) // (config['layers_per_block'] + 1)

  if any('downsample' in layer for layer in down_blocks[i]		):
   __A						:							List[str]      =						checkpoint[
       F"down.{i}.downsample.op.weight"
   ]
   __A						:							Optional[int]      =						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]		):
   __A						:							Union[str, Any]      =						len(
       {'.'.join(shave_segments(UpperCamelCase_  ,						2		).split('.'		)[:2]		) for layer in down_blocks[i] if 'block' in layer}		)
   __A						:							Optional[Any]      =						{
       layer_id: [key for key in down_blocks[i] if F"block.{layer_id}" in key]
       for layer_id in range(UpperCamelCase_		)
   }

   if num_blocks > 0:
    for j in range(config['layers_per_block']		):
     __A						:							Optional[Any]      =						renew_resnet_paths(blocks[j]		)
     assign_to_checkpoint(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_		)

  if any('attn' in layer for layer in down_blocks[i]		):
   __A						:							Optional[int]      =						len(
       {'.'.join(shave_segments(UpperCamelCase_  ,						2		).split('.'		)[:2]		) for layer in down_blocks[i] if 'attn' in layer}		)
   __A						:							Any      =						{
       layer_id: [key for key in down_blocks[i] if F"attn.{layer_id}" in key]
       for layer_id in range(UpperCamelCase_		)
   }

   if num_attn > 0:
    for j in range(config['layers_per_block']		):
     __A						:							Optional[Any]      =						renew_attention_paths(attns[j]		)
     assign_to_checkpoint(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						config=UpperCamelCase_		)

 __A						:							int      =						[key for key in checkpoint if 'mid.block_1' in key]
 __A						:							Any      =						[key for key in checkpoint if 'mid.block_2' in key]
 __A						:							str      =						[key for key in checkpoint if 'mid.attn_1' in key]

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

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

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

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

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

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

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

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

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

 __A						:							int      =						{k.replace('mid_new_2'  ,						'mid_block'		): v for k, v in new_checkpoint.items()}
 return new_checkpoint




def 					a			(  UpperCamelCase_				:					Dict  ,						UpperCamelCase_				:					Union[str, Any]		)	->		Union[str, Any]:
 __A						:							List[Any]      =						{}

 __A						:							Tuple      =						checkpoint['encoder.norm_out.weight']
 __A						:							int      =						checkpoint['encoder.norm_out.bias']

 __A						:							Optional[Any]      =						checkpoint['encoder.conv_in.weight']
 __A						:							str      =						checkpoint['encoder.conv_in.bias']
 __A						:							List[Any]      =						checkpoint['encoder.conv_out.weight']
 __A						:							List[Any]      =						checkpoint['encoder.conv_out.bias']

 __A						:							Any      =						checkpoint['decoder.norm_out.weight']
 __A						:							Optional[Any]      =						checkpoint['decoder.norm_out.bias']

 __A						:							List[str]      =						checkpoint['decoder.conv_in.weight']
 __A						:							Union[str, Any]      =						checkpoint['decoder.conv_in.bias']
 __A						:							int      =						checkpoint['decoder.conv_out.weight']
 __A						:							Dict      =						checkpoint['decoder.conv_out.bias']

 __A						:							List[Any]      =						len({'.'.join(layer.split('.'		)[:3]		) for layer in checkpoint if 'down' in layer}		)
 __A						:							Dict      =						{
     layer_id: [key for key in checkpoint if F"down.{layer_id}" in key] for layer_id in range(UpperCamelCase_		)
 }

 __A						:							Optional[Any]      =						len({'.'.join(layer.split('.'		)[:3]		) for layer in checkpoint if 'up' in layer}		)
 __A						:							Any      =						{layer_id: [key for key in checkpoint if F"up.{layer_id}" in key] for layer_id in range(UpperCamelCase_		)}

 for i in range(UpperCamelCase_		):
  __A						:							Dict      =						(i - 1) // (config['layers_per_block'] + 1)

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

  if any('block' in layer for layer in down_blocks[i]		):
   __A						:							Optional[int]      =						len(
       {'.'.join(shave_segments(UpperCamelCase_  ,						3		).split('.'		)[:3]		) for layer in down_blocks[i] if 'block' in layer}		)
   __A						:							Dict      =						{
       layer_id: [key for key in down_blocks[i] if F"block.{layer_id}" in key]
       for layer_id in range(UpperCamelCase_		)
   }

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

  if any('attn' in layer for layer in down_blocks[i]		):
   __A						:							Dict      =						len(
       {'.'.join(shave_segments(UpperCamelCase_  ,						3		).split('.'		)[:3]		) for layer in down_blocks[i] if 'attn' in layer}		)
   __A						:							List[Any]      =						{
       layer_id: [key for key in down_blocks[i] if F"attn.{layer_id}" in key]
       for layer_id in range(UpperCamelCase_		)
   }

   if num_attn > 0:
    for j in range(config['layers_per_block']		):
     __A						:							Union[str, Any]      =						renew_attention_paths(attns[j]		)
     assign_to_checkpoint(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						config=UpperCamelCase_		)

 __A						:							List[str]      =						[key for key in checkpoint if 'mid.block_1' in key]
 __A						:							Union[str, Any]      =						[key for key in checkpoint if 'mid.block_2' in key]
 __A						:							Optional[Any]      =						[key for key in checkpoint if 'mid.attn_1' in key]

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

 __A						:							List[Any]      =						renew_resnet_paths(UpperCamelCase_		)
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[{'old': 'mid.', 'new': 'mid_new_2.'}, {'old': 'block_2', 'new': 'resnets.1'}]  ,						)

 __A						:							Optional[Any]      =						renew_attention_paths(UpperCamelCase_  ,						in_mid=UpperCamelCase_		)
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[{'old': 'mid.', 'new': 'mid_new_2.'}, {'old': 'attn_1', 'new': 'attentions.0'}]  ,						)

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

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

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

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

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

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

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

 return new_checkpoint


if __name__ == "__main__":
   _UpperCamelCase :    List[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 :    Optional[Any]      =			torch.load(args.checkpoint_path)

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

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

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

   if config["_class_name"] == "VQModel":
      _UpperCamelCase :    Any      =			VQModel(**config)
      model.load_state_dict(converted_checkpoint)
      model.save_pretrained(args.dump_path)
   elif config["_class_name"] == "AutoencoderKL":
      _UpperCamelCase :    List[Any]      =			AutoencoderKL(**config)
      model.load_state_dict(converted_checkpoint)
      model.save_pretrained(args.dump_path)
   else:
      _UpperCamelCase :    Optional[int]      =			UNetaDModel(**config)
      model.load_state_dict(converted_checkpoint)

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

      _UpperCamelCase :    str      =			DDPMPipeline(unet=model, scheduler=scheduler)
      pipe.save_pretrained(args.dump_path)













"""simple docstring"""


def 					a			(  UpperCamelCase_				:					int  ,						UpperCamelCase_				:					int  ,						UpperCamelCase_				:					int  ,						UpperCamelCase_				:					int		)	->		int:
 return len_board * len_board_column * row + column




def 					a			(  UpperCamelCase_				:					list[list[str]]  ,						UpperCamelCase_				:					str  ,						UpperCamelCase_				:					int  ,						UpperCamelCase_				:					int  ,						UpperCamelCase_				:					int  ,						UpperCamelCase_				:					set[int]  ,						)	->		bool:

 if board[row][column] != word[word_index]:
  return False

 if word_index == len(UpperCamelCase_		) - 1:
  return True

 __A						:							List[str]      =						[(0, 1), (0, -1), (-1, 0), (1, 0)]
 __A						:							Any      =						len(UpperCamelCase_		)
 __A						:							Union[str, Any]      =						len(board[0]		)
 for direction in traverts_directions:
  __A						:							Any      =						row + direction[0]
  __A						:							List[Any]      =						column + direction[1]
  if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
   continue

  __A						:							Any      =						get_point_key(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_		)
  if key in visited_points_set:
   continue

  visited_points_set.add(UpperCamelCase_		)
  if exits_word(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						word_index + 1  ,						UpperCamelCase_		):
   return True

  visited_points_set.remove(UpperCamelCase_		)

 return False




def 					a			(  UpperCamelCase_				:					list[list[str]]  ,						UpperCamelCase_				:					str		)	->		bool:
 __A						:							Optional[Any]      =						(
     'The board should be a non empty matrix of single chars strings.'
 )

 __A						:							Dict      =						len(UpperCamelCase_		)
 if not isinstance(UpperCamelCase_  ,						UpperCamelCase_		) or len(UpperCamelCase_		) == 0:
  raise ValueError(UpperCamelCase_		)

 for row in board:
  if not isinstance(UpperCamelCase_  ,						UpperCamelCase_		) or len(UpperCamelCase_		) == 0:
   raise ValueError(UpperCamelCase_		)

  for item in row:
   if not isinstance(UpperCamelCase_  ,						UpperCamelCase_		) or len(UpperCamelCase_		) != 1:
    raise ValueError(UpperCamelCase_		)

    # Validate word
 if not isinstance(UpperCamelCase_  ,						UpperCamelCase_		) or len(UpperCamelCase_		) == 0:
  raise ValueError(
      'The word parameter should be a string of length greater than 0.'		)

 __A						:							List[Any]      =						len(board[0]		)
 for i in range(UpperCamelCase_		):
  for j in range(UpperCamelCase_		):
   if exits_word(
       UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						0  ,						{get_point_key(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_		)}		):
    return True

 return False


if __name__ == "__main__":
   import doctest

   doctest.testmod()





