






"""simple docstring"""


import argparse

import torch

from diffusers import UNetaDConditionModel




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

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

   __A						:							Optional[Any]      =						old_tensor.shape[0] // config['num_head_channels'] // 3

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

   __A						:							int      =						query.reshape(UpperCamelCase_		)
   __A						:							Dict      =						key.reshape(UpperCamelCase_		)
   __A						:							Any      =						value.reshape(UpperCamelCase_		)

 for path in paths:
  __A						:							List[str]      =						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:
    __A						:							str      =						new_path.replace(replacement['old']  ,						replacement['new']		)

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




def 					a			(  UpperCamelCase_				:					List[Any]  ,						UpperCamelCase_				:					Union[str, Any]=0		)	->		List[Any]:
 __A						:							Tuple      =						[]
 for old_item in old_list:
  __A						:							Optional[Any]      =						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			(  UpperCamelCase_				:					Tuple  ,						UpperCamelCase_				:					int=1		)	->		Optional[Any]:
 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_				:					Optional[int]  ,						UpperCamelCase_				:					Any=0		)	->		Optional[int]:
 __A						:							Union[str, Any]      =						[]
 for old_item in old_list:
  mapping.append({'old': old_item, 'new': old_item}		)

 return mapping




def 					a			(  UpperCamelCase_				:					Optional[Any]  ,						UpperCamelCase_				:					int=0		)	->		Any:
 __A						:							List[str]      =						[]
 for old_item in old_list:
  __A						:							List[str]      =						old_item.replace('in_layers.0'  ,						'norm1'		)
  __A						:							str      =						new_item.replace('in_layers.2'  ,						'conv1'		)

  __A						:							List[str]      =						new_item.replace('out_layers.0'  ,						'norm2'		)
  __A						:							Tuple      =						new_item.replace('out_layers.3'  ,						'conv2'		)

  __A						:							str      =						new_item.replace('emb_layers.1'  ,						'time_emb_proj'		)
  __A						:							str      =						new_item.replace('skip_connection'  ,						'conv_shortcut'		)

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

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

 return mapping




def 					a			(  UpperCamelCase_				:					str  ,						UpperCamelCase_				:					List[str]  ,						UpperCamelCase_				:					List[Any]=None  ,						UpperCamelCase_				:					Optional[int]=False		)	->		Tuple:
 __A						:							Optional[int]      =						{}
 __A						:							str      =						list(checkpoint.keys()		)

 __A						:							Tuple      =						'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		) > 1_0_0 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'		):
    __A						:							Union[str, Any]      =						'model_ema.' + ''.join(key.split('.'		)[1:]		)
    __A						:							str      =						checkpoint.pop(UpperCamelCase_		)
 else:
  if sum(k.startswith('model_ema'		) for k in keys		) > 1_0_0:
   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:
   __A						:							Union[str, Any]      =						checkpoint.pop(UpperCamelCase_		)

 __A						:							List[str]      =						{}

 __A						:							int      =						unet_state_dict['time_embed.0.weight']
 __A						:							int      =						unet_state_dict['time_embed.0.bias']
 __A						:							Dict      =						unet_state_dict['time_embed.2.weight']
 __A						:							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":
  __A						:							List[Any]      =						unet_state_dict['label_emb.0.0.weight']
  __A						:							Optional[int]      =						unet_state_dict['label_emb.0.0.bias']
  __A						:							Any      =						unet_state_dict['label_emb.0.2.weight']
  __A						:							Optional[Any]      =						unet_state_dict['label_emb.0.2.bias']
 else:
  raise NotImplementedError(F"Not implemented `class_embed_type`: {config['class_embed_type']}"		)

 __A						:							List[Any]      =						unet_state_dict['input_blocks.0.0.weight']
 __A						:							Union[str, Any]      =						unet_state_dict['input_blocks.0.0.bias']

 __A						:							Any      =						[v for v in unet_state_dict if v.startswith('input_blocks.0.1'		)]
 __A						:							Optional[Any]      =						renew_attention_paths(UpperCamelCase_		)
 __A						:							int      =						{'old': 'input_blocks.0.1', 'new': 'transformer_in'}
 assign_to_checkpoint(UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[meta_path]  ,						config=UpperCamelCase_		)

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

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

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

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

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

  __A						:							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
  ]
  __A						:							List[str]      =						[key for key in input_blocks[i] if F"input_blocks.{i}.1" in key]
  __A						:							Optional[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:
   __A						:							Dict      =						unet_state_dict.pop(
       F"input_blocks.{i}.op.weight"		)
   __A						:							Optional[Any]      =						unet_state_dict.pop(
       F"input_blocks.{i}.op.bias"		)

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

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

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

  if len(UpperCamelCase_		):
   __A						:							Optional[int]      =						renew_attention_paths(UpperCamelCase_		)
   __A						:							Any      =						{
       'old': F"input_blocks.{i}.2",
       'new': F"down_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
   }
   assign_to_checkpoint(
       UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[meta_path]  ,						config=UpperCamelCase_		)

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

 __A						:							str      =						renew_resnet_paths(UpperCamelCase_		)
 __A						:							List[Any]      =						{'old': 'middle_block.0', 'new': 'mid_block.resnets.0'}
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						config=UpperCamelCase_  ,						additional_replacements=[meta_path]		)

 __A						:							str      =						renew_temp_conv_paths(UpperCamelCase_		)
 __A						:							Dict      =						{'old': 'middle_block.0.temopral_conv', 'new': 'mid_block.temp_convs.0'}
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						config=UpperCamelCase_  ,						additional_replacements=[meta_path]		)

 __A						:							Any      =						renew_resnet_paths(UpperCamelCase_		)
 __A						:							List[Any]      =						{'old': 'middle_block.3', 'new': 'mid_block.resnets.1'}
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						config=UpperCamelCase_  ,						additional_replacements=[meta_path]		)

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

 __A						:							Tuple      =						renew_attention_paths(UpperCamelCase_		)
 __A						:							Optional[Any]      =						{'old': 'middle_block.1', 'new': 'mid_block.attentions.0'}
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[meta_path]  ,						config=UpperCamelCase_		)

 __A						:							Optional[Any]      =						renew_attention_paths(UpperCamelCase_		)
 __A						:							List[str]      =						{'old': 'middle_block.2', 'new': 'mid_block.temp_attentions.0'}
 assign_to_checkpoint(
     UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[meta_path]  ,						config=UpperCamelCase_		)

 for i in range(UpperCamelCase_		):
  __A						:							Optional[Any]      =						i // (config['layers_per_block'] + 1)
  __A						:							Dict      =						i % (config['layers_per_block'] + 1)
  __A						:							str      =						[shave_segments(UpperCamelCase_  ,						2		) for name in output_blocks[i]]
  __A						:							Any      =						{}

  for layer in output_block_layers:
   __A     ,       __A						:							Tuple      =						layer.split('.'		)[0], shave_segments(UpperCamelCase_  ,						1		)
   if layer_id in output_block_list:
    output_block_list[layer_id].append(UpperCamelCase_		)
   else:
    __A						:							Dict      =						[layer_name]

  if len(UpperCamelCase_		) > 1:
   __A						:							List[str]      =						[key for key in output_blocks[i] if F"output_blocks.{i}.0" in key]
   __A						:							Union[str, Any]      =						[key for key in output_blocks[i] if F"output_blocks.{i}.1" in key]
   __A						:							Dict      =						[key for key in output_blocks[i] if F"output_blocks.{i}.2" in key]

   __A						:							int      =						renew_resnet_paths(UpperCamelCase_		)
   __A						:							Optional[int]      =						renew_resnet_paths(UpperCamelCase_		)

   __A						:							Tuple      =						{'old': F"output_blocks.{i}.0", 'new': F"up_blocks.{block_id}.resnets.{layer_in_block_id}"}
   assign_to_checkpoint(
       UpperCamelCase_  ,						UpperCamelCase_  ,						UpperCamelCase_  ,						additional_replacements=[meta_path]  ,						config=UpperCamelCase_		)

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

   __A						:							Optional[Any]      =						{k: sorted(UpperCamelCase_		) for k, v in output_block_list.items()}
   if ["conv.bias", "conv.weight"] in output_block_list.values():
    __A						:							Any      =						list(output_block_list.values()		).index(['conv.bias', 'conv.weight']		)
    __A						:							str      =						unet_state_dict[
        F"output_blocks.{i}.{index}.conv.weight"
    ]
    __A						:							str      =						unet_state_dict[
        F"output_blocks.{i}.{index}.conv.bias"
    ]

    # Clear attentions as they have been attributed above.
    if len(UpperCamelCase_		) == 2:
     __A						:							int      =						[]

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

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

   __A						:							Optional[Any]      =						[l for l in output_block_layers if 'temopral_conv' in l]
   for path in temopral_conv_paths:
    __A						:							Tuple      =						path.split('temopral_conv.'		)[-1]
    __A						:							Dict      =						'.'.join(['output_blocks', str(UpperCamelCase_		), str(UpperCamelCase_		), 'temopral_conv', pruned_path]		)
    __A						:							str      =						'.'.join(['up_blocks', str(UpperCamelCase_		), 'temp_convs', str(UpperCamelCase_		), pruned_path]		)
    __A						:							Tuple      =						unet_state_dict[old_path]

 return new_checkpoint


if __name__ == "__main__":
   _UpperCamelCase :    List[str]      =			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 :    Optional[Any]      =			parser.parse_args()

   _UpperCamelCase :    int      =			torch.load(args.checkpoint_path, map_location="""cpu""")
   _UpperCamelCase :    Any      =			UNetaDConditionModel()

   _UpperCamelCase :    List[Any]      =			convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

   _UpperCamelCase :    Dict      =			set(unet.state_dict().keys()) - set(converted_ckpt.keys())
   _UpperCamelCase :    str      =			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 --













"""simple docstring"""


import math




def 					a			(  UpperCamelCase_				:					int		)	->		str:
 if number == 0:
  __A						:							Dict      =						'Zero'
  return words
 else:
  __A						:							List[str]      =						math.logaa(UpperCamelCase_		)
  __A						:							Union[str, Any]      =						digits + 1
  __A						:							List[str]      =						{}
  __A						:							int      =						''
  __A						:							Any      =						'One'
  __A						:							Tuple      =						'Two'
  __A						:							Any      =						'Three'
  __A						:							Any      =						'Four'
  __A						:							Optional[Any]      =						'Five'
  __A						:							List[Any]      =						'Six'
  __A						:							List[Any]      =						'Seven'
  __A						:							Dict      =						'Eight'
  __A						:							Union[str, Any]      =						'Nine'

  __A						:							List[Any]      =						{}
  __A						:							Tuple      =						''
  __A						:							List[Any]      =						'Twenty'
  __A						:							Optional[Any]      =						'Thirty'
  __A						:							Any      =						'Forty'
  __A						:							Optional[int]      =						'Fifty'
  __A						:							Dict      =						'Sixty'
  __A						:							Dict      =						'Seventy'
  __A						:							Optional[Any]      =						'Eighty'
  __A						:							Any      =						'Ninety'

  __A						:							int      =						{}
  __A						:							List[str]      =						'Ten'
  __A						:							Optional[Any]      =						'Eleven'
  __A						:							Dict      =						'Twelve'
  __A						:							Union[str, Any]      =						'Thirteen'
  __A						:							Union[str, Any]      =						'Fourteen'
  __A						:							Dict      =						'Fifteen'
  __A						:							str      =						'Sixteen'
  __A						:							str      =						'Seventeen'
  __A						:							Union[str, Any]      =						'Eighteen'
  __A						:							Union[str, Any]      =						'Nineteen'

  __A						:							Optional[Any]      =						{}
  __A						:							Optional[int]      =						'Hundred,'
  __A						:							Union[str, Any]      =						'Thousand,'
  __A						:							Union[str, Any]      =						'Lakh,'
  __A						:							Union[str, Any]      =						'Crore,'

  __A						:							Optional[Any]      =						number
  __A						:							Optional[Any]      =						''
  __A						:							List[str]      =						0
  __A						:							List[str]      =						int(UpperCamelCase_		)
  while counter < digits:
   __A						:							Any      =						temp_num % 1_0
   if counter % 2 == 0:
    __A						:							Optional[Any]      =						''
    if counter in placevalue and current != 0:
     __A						:							Union[str, Any]      =						placevalue[counter]
    if counter == 2:
     __A						:							Dict      =						singles[current] + addition + words
    elif counter == 0:
     if ((temp_num % 1_0_0) // 1_0) == 1:
      __A						:							Any      =						teens[current] + addition + words
      __A						:							int      =						temp_num // 1_0
      counter += 1
     else:
      __A						:							Optional[Any]      =						singles[current] + addition + words

    else:
     __A						:							str      =						doubles[current] + addition + words

   else:
    if counter == 1:
     if current == 1:
      __A						:							List[Any]      =						teens[number % 1_0] + words
     else:
      __A						:							Union[str, Any]      =						''
      if counter in placevalue:
       __A						:							int      =						placevalue[counter]
      __A						:							Optional[Any]      =						doubles[current] + addition + words
    else:
     __A						:							Any      =						''
     if counter in placevalue:
      if current == 0 and ((temp_num % 1_0_0) // 1_0) == 0:
       __A						:							Optional[int]      =						''
      else:
       __A						:							Optional[int]      =						placevalue[counter]
     if ((temp_num % 1_0_0) // 1_0) == 1:
      __A						:							Dict      =						teens[current] + addition + words
      __A						:							Any      =						temp_num // 1_0
      counter += 1
     else:
      __A						:							List[str]      =						singles[current] + addition + words
   counter += 1
   __A						:							Dict      =						temp_num // 1_0
 return words


if __name__ == "__main__":
   import doctest

   doctest.testmod()





