





import argparse
import json

import torch

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






def   lowerCamelCase_		(       _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   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase=0				)	->		List[Any]:






				"""simple docstring"""


				snake_case_		:					Tuple			    =						[]
				for old_item in old_list:
								snake_case_		:					List[Any]			    =						old_item
								snake_case_		:					Union[str, Any]			    =						new_item.replace('''block.'''				,       '''resnets.'''				)
								snake_case_		:					int			    =						new_item.replace('''conv_shorcut'''				,       '''conv1'''				)
								snake_case_		:					int			    =						new_item.replace('''in_shortcut'''				,       '''conv_shortcut'''				)
								snake_case_		:					Tuple			    =						new_item.replace('''temb_proj'''				,       '''time_emb_proj'''				)

								snake_case_		:					Dict			    =						shave_segments(_UpperCamelCase				,       n_shave_prefix_segments=_UpperCamelCase				)

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

				return mapping






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase=0				,       _UpperCamelCase=False				)	->		str:






				"""simple docstring"""


				snake_case_		:					Union[str, Any]			    =						[]
				for old_item in old_list:
								snake_case_		:					Any			    =						old_item

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

								snake_case_		:					Any			    =						new_item.replace('''proj_out'''				,       '''proj_attn'''				)
								snake_case_		:					Optional[Any]			    =						new_item.replace('''norm'''				,       '''group_norm'''				)

								snake_case_		:					Optional[Any]			    =						shave_segments(_UpperCamelCase				,       n_shave_prefix_segments=_UpperCamelCase				)
								mapping.append({'''old''': old_item, '''new''': new_item}				)

				return mapping






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase=None				,       _UpperCamelCase=None				,       _UpperCamelCase=None				)	->		List[Any]:






				"""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():
												snake_case_		:					Dict			    =						old_checkpoint[path]
												snake_case_		:					Dict			    =						old_tensor.shape[0] // 3

												snake_case_		:					Any			    =						(-1, channels) if len(old_tensor.shape				) == 3 else (-1)

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

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

												snake_case_		:					List[str]			    =						query.reshape(_UpperCamelCase				).squeeze()
												snake_case_		:					int			    =						key.reshape(_UpperCamelCase				).squeeze()
												snake_case_		:					str			    =						value.reshape(_UpperCamelCase				).squeeze()

				for path in paths:
								snake_case_		:					Optional[int]			    =						path['''new''']

								if attention_paths_to_split is not None and new_path in attention_paths_to_split:
												continue

								snake_case_		:					int			    =						new_path.replace('''down.'''				,       '''down_blocks.'''				)
								snake_case_		:					int			    =						new_path.replace('''up.'''				,       '''up_blocks.'''				)

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

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






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				)	->		Dict:






				"""simple docstring"""


				snake_case_		:					str			    =						{}

				snake_case_		:					Tuple			    =						checkpoint['''temb.dense.0.weight''']
				snake_case_		:					Any			    =						checkpoint['''temb.dense.0.bias''']
				snake_case_		:					List[str]			    =						checkpoint['''temb.dense.1.weight''']
				snake_case_		:					Tuple			    =						checkpoint['''temb.dense.1.bias''']

				snake_case_		:					Dict			    =						checkpoint['''norm_out.weight''']
				snake_case_		:					List[Any]			    =						checkpoint['''norm_out.bias''']

				snake_case_		:					Any			    =						checkpoint['''conv_in.weight''']
				snake_case_		:					Dict			    =						checkpoint['''conv_in.bias''']
				snake_case_		:					str			    =						checkpoint['''conv_out.weight''']
				snake_case_		:					List[str]			    =						checkpoint['''conv_out.bias''']

				snake_case_		:					Dict			    =						len({'''.'''.join(layer.split('''.'''				)[:2]				) for layer in checkpoint if '''down''' in layer}				)
				snake_case_		:					Dict			    =						{
				    layer_id: [key for key in checkpoint if f'''down.{layer_id}''' in key] for layer_id in range(_UpperCamelCase				)
				}

				snake_case_		:					Optional[Any]			    =						len({'''.'''.join(layer.split('''.'''				)[:2]				) for layer in checkpoint if '''up''' in layer}				)
				snake_case_		:					List[str]			    =						{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				):
								snake_case_		:					Union[str, Any]			    =						(i - 1) // (config['''layers_per_block'''] + 1)

								if any('''downsample''' in layer for layer in down_blocks[i]				):
												snake_case_		:					Any			    =						checkpoint[
												    f'''down.{i}.downsample.op.weight'''
												]
												snake_case_		:					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]				):
												snake_case_		:					List[Any]			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       2				).split('''.'''				)[:2]				) for layer in down_blocks[i] if '''block''' in layer}				)
												snake_case_		:					str			    =						{
												    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''']				):
																				snake_case_		:					Optional[Any]			    =						renew_resnet_paths(blocks[j]				)
																				assign_to_checkpoint(_UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				)

								if any('''attn''' in layer for layer in down_blocks[i]				):
												snake_case_		:					int			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       2				).split('''.'''				)[:2]				) for layer in down_blocks[i] if '''attn''' in layer}				)
												snake_case_		:					str			    =						{
												    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''']				):
																				snake_case_		:					Dict			    =						renew_attention_paths(attns[j]				)
																				assign_to_checkpoint(_UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       config=_UpperCamelCase				)

				snake_case_		:					str			    =						[key for key in checkpoint if '''mid.block_1''' in key]
				snake_case_		:					Union[str, Any]			    =						[key for key in checkpoint if '''mid.block_2''' in key]
				snake_case_		:					Dict			    =						[key for key in checkpoint if '''mid.attn_1''' in key]

				# Mid new 2
				snake_case_		:					int			    =						renew_resnet_paths(_UpperCamelCase				)
				assign_to_checkpoint(
				    _UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]				,       )

				snake_case_		:					str			    =						renew_resnet_paths(_UpperCamelCase				)
				assign_to_checkpoint(
				    _UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]				,       )

				snake_case_		:					List[str]			    =						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				):
								snake_case_		:					Tuple			    =						num_up_blocks - 1 - i

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

								if any('''block''' in layer for layer in up_blocks[i]				):
												snake_case_		:					Optional[Any]			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       2				).split('''.'''				)[:2]				) for layer in up_blocks[i] if '''block''' in layer}				)
												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(_UpperCamelCase				)
												}

												if num_blocks > 0:
																for j in range(config['''layers_per_block'''] + 1				):
																				snake_case_		:					Optional[Any]			    =						{'''old''': f'''up_blocks.{i}''', '''new''': f'''up_blocks.{block_id}'''}
																				snake_case_		:					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]				):
												snake_case_		:					str			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       2				).split('''.'''				)[:2]				) for layer in up_blocks[i] if '''attn''' in layer}				)
												snake_case_		:					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				):
																				snake_case_		:					Any			    =						{'''old''': f'''up_blocks.{i}''', '''new''': f'''up_blocks.{block_id}'''}
																				snake_case_		:					Tuple			    =						renew_attention_paths(attns[j]				)
																				assign_to_checkpoint(_UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       additional_replacements=[replace_indices]				)

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






def   lowerCamelCase_		(       _UpperCamelCase				,       _UpperCamelCase				)	->		int:






				"""simple docstring"""


				snake_case_		:					Optional[int]			    =						{}

				snake_case_		:					List[Any]			    =						checkpoint['''encoder.norm_out.weight''']
				snake_case_		:					int			    =						checkpoint['''encoder.norm_out.bias''']

				snake_case_		:					Optional[int]			    =						checkpoint['''encoder.conv_in.weight''']
				snake_case_		:					Optional[Any]			    =						checkpoint['''encoder.conv_in.bias''']
				snake_case_		:					Tuple			    =						checkpoint['''encoder.conv_out.weight''']
				snake_case_		:					int			    =						checkpoint['''encoder.conv_out.bias''']

				snake_case_		:					List[Any]			    =						checkpoint['''decoder.norm_out.weight''']
				snake_case_		:					Dict			    =						checkpoint['''decoder.norm_out.bias''']

				snake_case_		:					List[str]			    =						checkpoint['''decoder.conv_in.weight''']
				snake_case_		:					Tuple			    =						checkpoint['''decoder.conv_in.bias''']
				snake_case_		:					List[str]			    =						checkpoint['''decoder.conv_out.weight''']
				snake_case_		:					List[str]			    =						checkpoint['''decoder.conv_out.bias''']

				snake_case_		:					Dict			    =						len({'''.'''.join(layer.split('''.'''				)[:3]				) for layer in checkpoint if '''down''' in layer}				)
				snake_case_		:					str			    =						{
				    layer_id: [key for key in checkpoint if f'''down.{layer_id}''' in key] for layer_id in range(_UpperCamelCase				)
				}

				snake_case_		:					List[Any]			    =						len({'''.'''.join(layer.split('''.'''				)[:3]				) for layer in checkpoint if '''up''' in layer}				)
				snake_case_		:					List[str]			    =						{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				):
								snake_case_		:					int			    =						(i - 1) // (config['''layers_per_block'''] + 1)

								if any('''downsample''' in layer for layer in down_blocks[i]				):
												snake_case_		:					List[str]			    =						checkpoint[
												    f'''encoder.down.{i}.downsample.conv.weight'''
												]
												snake_case_		:					Tuple			    =						checkpoint[
												    f'''encoder.down.{i}.downsample.conv.bias'''
												]

								if any('''block''' in layer for layer in down_blocks[i]				):
												snake_case_		:					int			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       3				).split('''.'''				)[:3]				) for layer in down_blocks[i] if '''block''' in layer}				)
												snake_case_		:					int			    =						{
												    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''']				):
																				snake_case_		:					List[str]			    =						renew_resnet_paths(blocks[j]				)
																				assign_to_checkpoint(_UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				)

								if any('''attn''' in layer for layer in down_blocks[i]				):
												snake_case_		:					Dict			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       3				).split('''.'''				)[:3]				) for layer in down_blocks[i] if '''attn''' in layer}				)
												snake_case_		:					Union[str, 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''']				):
																				snake_case_		:					Optional[Any]			    =						renew_attention_paths(attns[j]				)
																				assign_to_checkpoint(_UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       config=_UpperCamelCase				)

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

				# Mid new 2
				snake_case_		:					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'''}]				,       )

				snake_case_		:					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'''}]				,       )

				snake_case_		:					Tuple			    =						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				):
								snake_case_		:					Any			    =						num_up_blocks - 1 - i

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

								if any('''block''' in layer for layer in up_blocks[i]				):
												snake_case_		:					Dict			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       3				).split('''.'''				)[:3]				) for layer in up_blocks[i] if '''block''' in layer}				)
												snake_case_		:					Union[str, 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				):
																				snake_case_		:					Tuple			    =						{'''old''': f'''up_blocks.{i}''', '''new''': f'''up_blocks.{block_id}'''}
																				snake_case_		:					Any			    =						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]				):
												snake_case_		:					Dict			    =						len(
												    {'''.'''.join(shave_segments(_UpperCamelCase				,       3				).split('''.'''				)[:3]				) for layer in up_blocks[i] if '''attn''' in layer}				)
												snake_case_		:					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				):
																				snake_case_		:					Tuple			    =						{'''old''': f'''up_blocks.{i}''', '''new''': f'''up_blocks.{block_id}'''}
																				snake_case_		:					Optional[int]			    =						renew_attention_paths(attns[j]				)
																				assign_to_checkpoint(_UpperCamelCase				,       _UpperCamelCase				,       _UpperCamelCase				,       additional_replacements=[replace_indices]				)

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

				return new_checkpoint


if __name__ == "__main__":
	lowerCAmelCase_												=       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_												=       parser.parse_args()
	lowerCAmelCase_												=       torch.load(args.checkpoint_path)

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

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

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

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

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

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







class       __lowerCAmelCase :






			def __init__(self					)  ->     Dict:


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						[]
							snake_case_		:					Any			    =						0
							snake_case_		:					Optional[int]			    =						0






			def __str__(self					)  ->     Dict:


							'''simple docstring'''



							snake_case_		:					int			    =						'''<''' + str(self.entries					)[1:-1] + '''>'''
							return printed






			def     lowerCamelCase						(self      ,							__magic_name__					)  ->     Dict:


							'''simple docstring'''



							self.entries.append(__magic_name__					)
							snake_case_		:					List[str]			    =						self.length + 1






			def     lowerCamelCase						(self					)  ->     Tuple:


							'''simple docstring'''



							snake_case_		:					Union[str, Any]			    =						self.length - 1
							snake_case_		:					Dict			    =						self.entries[self.front]
							# self.front-=1
							# self.entries = self.entries[self.front:]
							snake_case_		:					List[str]			    =						self.entries[1:]
							return dequeued






			def     lowerCamelCase						(self      ,							__magic_name__					)  ->     Optional[Any]:


							'''simple docstring'''



							for _ in range(__magic_name__					):
											self.put(self.get()					)






			def     lowerCamelCase						(self					)  ->     Optional[Any]:


							'''simple docstring'''



							return self.entries[0]






			def     lowerCamelCase						(self					)  ->     Union[str, Any]:


							'''simple docstring'''



							return self.length
