code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  import argparse
  import json
  
  import torch
  
  from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNetaDModel, VQModel
  
  
  
  
  def        __a (     UpperCAmelCase       ,			UpperCAmelCase=1    )      ->int:
  
  
  
  	"""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 (     UpperCAmelCase       ,			UpperCAmelCase=0    )      ->str:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      []
  	for old_item in old_list:
  		A							  =      old_item
  		A							  =      new_item.replace("""block."""       ,			"""resnets."""    )
  		A							  =      new_item.replace("""conv_shorcut"""       ,			"""conv1"""    )
  		A							  =      new_item.replace("""in_shortcut"""       ,			"""conv_shortcut"""    )
  		A							  =      new_item.replace("""temb_proj"""       ,			"""time_emb_proj"""    )
  
  		A							  =      shave_segments(UpperCAmelCase       ,			n_shave_prefix_segments=UpperCAmelCase    )
  
  		mapping.append({"""old""": old_item, """new""": new_item}    )
  
  	return mapping
  
  
  
  
  def        __a (     UpperCAmelCase       ,			UpperCAmelCase=0       ,			UpperCAmelCase=False    )      ->Optional[Any]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      []
  	for old_item in old_list:
  		A							  =      old_item
  
  		# In `model.mid`, the layer is called `attn`.
  		if not in_mid:
  			A							  =      new_item.replace("""attn"""       ,			"""attentions"""    )
  		A							  =      new_item.replace(""".k."""       ,			""".key."""    )
  		A							  =      new_item.replace(""".v."""       ,			""".value."""    )
  		A							  =      new_item.replace(""".q."""       ,			""".query."""    )
  
  		A							  =      new_item.replace("""proj_out"""       ,			"""proj_attn"""    )
  		A							  =      new_item.replace("""norm"""       ,			"""group_norm"""    )
  
  		A							  =      shave_segments(UpperCAmelCase       ,			n_shave_prefix_segments=UpperCAmelCase    )
  		mapping.append({"""old""": old_item, """new""": new_item}    )
  
  	return mapping
  
  
  
  
  def        __a (     UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase=None       ,			UpperCAmelCase=None       ,			UpperCAmelCase=None    )      ->Dict:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	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							  =      old_checkpoint[path]
  			A							  =      old_tensor.shape[0] // 3
  
  			A							  =      (-1, channels) if len(old_tensor.shape    ) == 3 else (-1)
  
  			A							  =      old_tensor.shape[0] // config.get("""num_head_channels"""       ,			1    ) // 3
  
  			A							  =      old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]    )
  			A  ,    A  ,    A							  =      old_tensor.split(channels // num_heads       ,			dim=1    )
  
  			A							  =      query.reshape(UpperCAmelCase    ).squeeze()
  			A							  =      key.reshape(UpperCAmelCase    ).squeeze()
  			A							  =      value.reshape(UpperCAmelCase    ).squeeze()
  
  	for path in paths:
  		A							  =      path["""new"""]
  
  		if attention_paths_to_split is not None and new_path in attention_paths_to_split:
  			continue
  
  		A							  =      new_path.replace("""down."""       ,			"""down_blocks."""    )
  		A							  =      new_path.replace("""up."""       ,			"""up_blocks."""    )
  
  		if additional_replacements is not None:
  			for replacement in additional_replacements:
  				A							  =      new_path.replace(replacement["""old"""]       ,			replacement["""new"""]    )
  
  		if "attentions" in new_path:
  			A							  =      old_checkpoint[path["""old"""]].squeeze()
  		else:
  			A							  =      old_checkpoint[path["""old"""]]
  
  
  
  
  def        __a (     UpperCAmelCase       ,			UpperCAmelCase    )      ->Optional[Any]:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      {}
  
  	A							  =      checkpoint["""temb.dense.0.weight"""]
  	A							  =      checkpoint["""temb.dense.0.bias"""]
  	A							  =      checkpoint["""temb.dense.1.weight"""]
  	A							  =      checkpoint["""temb.dense.1.bias"""]
  
  	A							  =      checkpoint["""norm_out.weight"""]
  	A							  =      checkpoint["""norm_out.bias"""]
  
  	A							  =      checkpoint["""conv_in.weight"""]
  	A							  =      checkpoint["""conv_in.bias"""]
  	A							  =      checkpoint["""conv_out.weight"""]
  	A							  =      checkpoint["""conv_out.bias"""]
  
  	A							  =      len({""".""".join(layer.split("""."""    )[:2]    ) for layer in checkpoint if """down""" in layer}    )
  	A							  =      {
  	    layer_id: [key for key in checkpoint if f"""down.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
  	}
  
  	A							  =      len({""".""".join(layer.split("""."""    )[:2]    ) for layer in checkpoint if """up""" in layer}    )
  	A							  =      {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							  =      (i - 1) // (config["""layers_per_block"""] + 1)
  
  		if any("""downsample""" in layer for layer in down_blocks[i]    ):
  			A							  =      checkpoint[
  			    f"""down.{i}.downsample.op.weight"""
  			]
  			A							  =      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							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in down_blocks[i] if """block""" in layer}    )
  			A							  =      {
  			    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							  =      renew_resnet_paths(blocks[j]    )
  					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase    )
  
  		if any("""attn""" in layer for layer in down_blocks[i]    ):
  			A							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in down_blocks[i] if """attn""" in layer}    )
  			A							  =      {
  			    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							  =      renew_attention_paths(attns[j]    )
  					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			config=UpperCAmelCase    )
  
  	A							  =      [key for key in checkpoint if """mid.block_1""" in key]
  	A							  =      [key for key in checkpoint if """mid.block_2""" in key]
  	A							  =      [key for key in checkpoint if """mid.attn_1""" in key]
  
  	# Mid new 2
  	A							  =      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							  =      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							  =      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							  =      num_up_blocks - 1 - i
  
  		if any("""upsample""" in layer for layer in up_blocks[i]    ):
  			A							  =      checkpoint[
  			    f"""up.{i}.upsample.conv.weight"""
  			]
  			A							  =      checkpoint[f"""up.{i}.upsample.conv.bias"""]
  
  		if any("""block""" in layer for layer in up_blocks[i]    ):
  			A							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in up_blocks[i] if """block""" in layer}    )
  			A							  =      {
  			    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							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
  					A							  =      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							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			2    ).split("""."""    )[:2]    ) for layer in up_blocks[i] if """attn""" in layer}    )
  			A							  =      {
  			    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							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
  					A							  =      renew_attention_paths(attns[j]    )
  					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[replace_indices]    )
  
  	A							  =      {k.replace("""mid_new_2"""       ,			"""mid_block"""    ): v for k, v in new_checkpoint.items()}
  	return new_checkpoint
  
  
  
  
  def        __a (     UpperCAmelCase       ,			UpperCAmelCase    )      ->Dict:
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	A							  =      {}
  
  	A							  =      checkpoint["""encoder.norm_out.weight"""]
  	A							  =      checkpoint["""encoder.norm_out.bias"""]
  
  	A							  =      checkpoint["""encoder.conv_in.weight"""]
  	A							  =      checkpoint["""encoder.conv_in.bias"""]
  	A							  =      checkpoint["""encoder.conv_out.weight"""]
  	A							  =      checkpoint["""encoder.conv_out.bias"""]
  
  	A							  =      checkpoint["""decoder.norm_out.weight"""]
  	A							  =      checkpoint["""decoder.norm_out.bias"""]
  
  	A							  =      checkpoint["""decoder.conv_in.weight"""]
  	A							  =      checkpoint["""decoder.conv_in.bias"""]
  	A							  =      checkpoint["""decoder.conv_out.weight"""]
  	A							  =      checkpoint["""decoder.conv_out.bias"""]
  
  	A							  =      len({""".""".join(layer.split("""."""    )[:3]    ) for layer in checkpoint if """down""" in layer}    )
  	A							  =      {
  	    layer_id: [key for key in checkpoint if f"""down.{layer_id}""" in key] for layer_id in range(UpperCAmelCase    )
  	}
  
  	A							  =      len({""".""".join(layer.split("""."""    )[:3]    ) for layer in checkpoint if """up""" in layer}    )
  	A							  =      {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							  =      (i - 1) // (config["""layers_per_block"""] + 1)
  
  		if any("""downsample""" in layer for layer in down_blocks[i]    ):
  			A							  =      checkpoint[
  			    f"""encoder.down.{i}.downsample.conv.weight"""
  			]
  			A							  =      checkpoint[
  			    f"""encoder.down.{i}.downsample.conv.bias"""
  			]
  
  		if any("""block""" in layer for layer in down_blocks[i]    ):
  			A							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in down_blocks[i] if """block""" in layer}    )
  			A							  =      {
  			    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							  =      renew_resnet_paths(blocks[j]    )
  					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase    )
  
  		if any("""attn""" in layer for layer in down_blocks[i]    ):
  			A							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in down_blocks[i] if """attn""" in layer}    )
  			A							  =      {
  			    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							  =      renew_attention_paths(attns[j]    )
  					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			config=UpperCAmelCase    )
  
  	A							  =      [key for key in checkpoint if """mid.block_1""" in key]
  	A							  =      [key for key in checkpoint if """mid.block_2""" in key]
  	A							  =      [key for key in checkpoint if """mid.attn_1""" in key]
  
  	# Mid new 2
  	A							  =      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							  =      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							  =      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							  =      num_up_blocks - 1 - i
  
  		if any("""upsample""" in layer for layer in up_blocks[i]    ):
  			A							  =      checkpoint[
  			    f"""decoder.up.{i}.upsample.conv.weight"""
  			]
  			A							  =      checkpoint[
  			    f"""decoder.up.{i}.upsample.conv.bias"""
  			]
  
  		if any("""block""" in layer for layer in up_blocks[i]    ):
  			A							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in up_blocks[i] if """block""" in layer}    )
  			A							  =      {
  			    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							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
  					A							  =      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							  =      len(
  			    {""".""".join(shave_segments(UpperCAmelCase       ,			3    ).split("""."""    )[:3]    ) for layer in up_blocks[i] if """attn""" in layer}    )
  			A							  =      {
  			    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							  =      {"""old""": f"""up_blocks.{i}""", """new""": f"""up_blocks.{block_id}"""}
  					A							  =      renew_attention_paths(attns[j]    )
  					assign_to_checkpoint(UpperCAmelCase       ,			UpperCAmelCase       ,			UpperCAmelCase       ,			additional_replacements=[replace_indices]    )
  
  	A							  =      {k.replace("""mid_new_2"""       ,			"""mid_block"""    ): v for k, v in new_checkpoint.items()}
  	A							  =      checkpoint["""quant_conv.weight"""]
  	A							  =      checkpoint["""quant_conv.bias"""]
  	if "quantize.embedding.weight" in checkpoint:
  		A							  =      checkpoint["""quantize.embedding.weight"""]
  	A							  =      checkpoint["""post_quant_conv.weight"""]
  	A							  =      checkpoint["""post_quant_conv.bias"""]
  
  	return new_checkpoint
  
  
  if __name__ == "__main__":
  				_lowerCamelCase				:	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(
  				    '--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.')
  
  				_lowerCamelCase				:	List[Any]				    =       parser.parse_args()
  				_lowerCamelCase				:	Optional[Any]				    =       torch.load(args.checkpoint_path)
  
  				with open(args.config_file) as f:
  								_lowerCamelCase				:	str				    =       json.loads(f.read())
  
  				# unet case
  				_lowerCamelCase				:	List[str]				    =       {key.split('.')[0] for key in checkpoint.keys()}
  				if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
  								_lowerCamelCase				:	Dict				    =       convert_vq_autoenc_checkpoint(checkpoint, config)
  				else:
  								_lowerCamelCase				:	Optional[int]				    =       convert_ddpm_checkpoint(checkpoint, config)
  
  				if "ddpm" in config:
  								del config["ddpm"]
  
  				if config["_class_name"] == "VQModel":
  								_lowerCamelCase				:	List[str]				    =       VQModel(**config)
  								model.load_state_dict(converted_checkpoint)
  								model.save_pretrained(args.dump_path)
  				elif config["_class_name"] == "AutoencoderKL":
  								_lowerCamelCase				:	Optional[int]				    =       AutoencoderKL(**config)
  								model.load_state_dict(converted_checkpoint)
  								model.save_pretrained(args.dump_path)
  				else:
  								_lowerCamelCase				:	List[str]				    =       UNetaDModel(**config)
  								model.load_state_dict(converted_checkpoint)
  
  								_lowerCamelCase				:	Optional[Any]				    =       DDPMScheduler.from_config('/'.join(args.checkpoint_path.split('/')[:-1]))
  
  								_lowerCamelCase				:	List[Any]				    =       DDPMPipeline(unet=model, scheduler=scheduler)
  								pipe.save_pretrained(args.dump_path)
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  class 							__UpperCAmelCase  :
  
  
  
  
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def __init__(self						:      List[str]      ):
  			# numbermap keys are the number and its values are lists of indexes sorted
  			# in ascending order
  			A							  =      {}
  			# indexmap keys are an index and it's values are the number at that index
  			A							  =      {}
  
  
  
  
  
  
  
  		def        A     (self						:      Union[str, Any]      ,      _lowerCAmelCase						:      list | str | range      ,      _lowerCAmelCase						:      int      ):
  			if isinstance(_lowerCAmelCase      ,      (range, str)      ):
  				A							  =      list(_lowerCAmelCase      )
  			elif not isinstance(_lowerCAmelCase      ,      _lowerCAmelCase      ):
  				raise TypeError(
  				    """binary_search_delete() only accepts either a list, range or str"""      )
  
  			A							  =      0
  			A							  =      len(_lowerCAmelCase      ) - 1
  
  			while low <= high:
  				A							  =      (low + high) // 2
  				if array[mid] == item:
  					array.pop(_lowerCAmelCase      )
  					return array
  				elif array[mid] < item:
  					A							  =      mid + 1
  				else:
  					A							  =      mid - 1
  			raise ValueError(
  			    """Either the item is not in the array or the array was unsorted"""      )
  
  
  
  
  
  
  
  		def        A     (self						:      Dict      ,      _lowerCAmelCase						:      list | str | range      ,      _lowerCAmelCase						:      int      ):
  			if isinstance(_lowerCAmelCase      ,      (range, str)      ):
  				A							  =      list(_lowerCAmelCase      )
  			elif not isinstance(_lowerCAmelCase      ,      _lowerCAmelCase      ):
  				raise TypeError(
  				    """binary_search_insert() only accepts either a list, range or str"""      )
  
  			A							  =      0
  			A							  =      len(_lowerCAmelCase      ) - 1
  
  			while low <= high:
  				A							  =      (low + high) // 2
  				if array[mid] == index:
  					# If the item already exists in the array,
  					# insert it after the existing item
  					array.insert(mid + 1      ,      _lowerCAmelCase      )
  					return array
  				elif array[mid] < index:
  					A							  =      mid + 1
  				else:
  					A							  =      mid - 1
  
          # If the item doesn't exist in the array, insert it at the appropriate position
  			array.insert(_lowerCAmelCase      ,      _lowerCAmelCase      )
  			return array
  
  
  
  
  
  
  
  		def        A     (self						:      List[str]      ,      _lowerCAmelCase						:      int      ,      _lowerCAmelCase						:      int      ):
  			# Remove previous index
  			if index in self.indexmap:
  				A							  =      self.indexmap[index]
  				if len(self.numbermap[n]      ) == 1:
  					del self.numbermap[n]
  				else:
  					A							  =      self.binary_search_delete(self.numbermap[n]      ,      _lowerCAmelCase      )
  
          # Set new index
  			A							  =      number
  
  			# Number not seen before or empty so insert number value
  			if number not in self.numbermap:
  				A							  =      [index]
  
  			# Here we need to perform a binary search insertion in order to insert
  			# The item in the correct place
  			else:
  				A							  =      self.binary_search_insert(
  				    self.numbermap[number]      ,      _lowerCAmelCase      )
  
  
  
  
  
  
  
  		def        A     (self						:      int      ,      _lowerCAmelCase						:      int      ):
  			return self.numbermap.get(_lowerCAmelCase      ,      [-1]      )[0]
  
  
  if __name__ == "__main__":
  				import doctest
  
  				doctest.testmod()
  
  