"""simple docstring"""







import argparse
import json

import torch

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


def   a__      (		UpperCAmelCase__       :			Optional[Any]		,			UpperCAmelCase__       :			Dict=1			)->	int:
						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__       :			Optional[int]=0			)->	Any:
						UpperCAmelCase__						=		[]
						for old_item in old_list:
												UpperCAmelCase__						=		old_item
												UpperCAmelCase__						=		new_item.replace("""block."""		,			"""resnets."""			)
												UpperCAmelCase__						=		new_item.replace("""conv_shorcut"""		,			"""conv1"""			)
												UpperCAmelCase__						=		new_item.replace("""in_shortcut"""		,			"""conv_shortcut"""			)
												UpperCAmelCase__						=		new_item.replace("""temb_proj"""		,			"""time_emb_proj"""			)

												UpperCAmelCase__						=		shave_segments(lowercase_		,			n_shave_prefix_segments=lowercase_			)

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

						return mapping


def   a__      (		UpperCAmelCase__       :			Optional[Any]		,			UpperCAmelCase__       :			Optional[int]=0		,			UpperCAmelCase__       :			int=False			)->	Tuple:
						UpperCAmelCase__						=		[]
						for old_item in old_list:
												UpperCAmelCase__						=		old_item

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

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

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

						return mapping


def   a__      (		UpperCAmelCase__       :			Union[str, Any]		,			UpperCAmelCase__       :			List[str]		,			UpperCAmelCase__       :			Any		,			UpperCAmelCase__       :			List[Any]=None		,			UpperCAmelCase__       :			str=None		,			UpperCAmelCase__       :			Optional[Any]=None			)->	str:
						assert isinstance(lowercase_		,			lowercase_			), "Paths should be a list of dicts containing 'old' and 'new' keys."

						if attention_paths_to_split is not None:
												if config is None:
																		raise ValueError("""Please specify the config if setting \'attention_paths_to_split\' to \'True\'."""			)

												for path, path_map in attention_paths_to_split.items():
																		UpperCAmelCase__						=		old_checkpoint[path]
																		UpperCAmelCase__						=		old_tensor.shape[0] // 3

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

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

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

																		UpperCAmelCase__						=		query.reshape(lowercase_			).squeeze()
																		UpperCAmelCase__						=		key.reshape(lowercase_			).squeeze()
																		UpperCAmelCase__						=		value.reshape(lowercase_			).squeeze()

						for path in paths:
												UpperCAmelCase__						=		path['new']

												if attention_paths_to_split is not None and new_path in attention_paths_to_split:
																		continue

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

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

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


def   a__      (		UpperCAmelCase__       :			List[str]		,			UpperCAmelCase__       :			Any			)->	List[Any]:
						UpperCAmelCase__						=		{}

						UpperCAmelCase__						=		checkpoint['temb.dense.0.weight']
						UpperCAmelCase__						=		checkpoint['temb.dense.0.bias']
						UpperCAmelCase__						=		checkpoint['temb.dense.1.weight']
						UpperCAmelCase__						=		checkpoint['temb.dense.1.bias']

						UpperCAmelCase__						=		checkpoint['norm_out.weight']
						UpperCAmelCase__						=		checkpoint['norm_out.bias']

						UpperCAmelCase__						=		checkpoint['conv_in.weight']
						UpperCAmelCase__						=		checkpoint['conv_in.bias']
						UpperCAmelCase__						=		checkpoint['conv_out.weight']
						UpperCAmelCase__						=		checkpoint['conv_out.bias']

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

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

						for i in range(lowercase_			):
												UpperCAmelCase__						=		(i - 1) // (config['layers_per_block'] + 1)

												if any("""downsample""" in layer for layer in down_blocks[i]			):
																		UpperCAmelCase__						=		checkpoint[
																		    f'down.{i}.downsample.op.weight'
																		]
																		UpperCAmelCase__						=		checkpoint[f'down.{i}.downsample.op.bias']
												#            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.weight'] = checkpoint[f'down.{i}.downsample.conv.weight']
												#            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.bias'] = checkpoint[f'down.{i}.downsample.conv.bias']

												if any("""block""" in layer for layer in down_blocks[i]			):
																		UpperCAmelCase__						=		len(
																		    {""".""".join(shave_segments(lowercase_		,			2			).split("""."""			)[:2]			) for layer in down_blocks[i] if """block""" in layer}			)
																		UpperCAmelCase__						=		{
																		    layer_id: [key for key in down_blocks[i] if f'block.{layer_id}' in key]
																		    for layer_id in range(lowercase_			)
																		}

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

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

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

						UpperCAmelCase__						=		[key for key in checkpoint if 'mid.block_1' in key]
						UpperCAmelCase__						=		[key for key in checkpoint if 'mid.block_2' in key]
						UpperCAmelCase__						=		[key for key in checkpoint if 'mid.attn_1' in key]

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

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

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

						for i in range(lowercase_			):
												UpperCAmelCase__						=		num_up_blocks - 1 - i

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

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

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

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

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

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


def   a__      (		UpperCAmelCase__       :			Optional[int]		,			UpperCAmelCase__       :			Dict			)->	List[str]:
						UpperCAmelCase__						=		{}

						UpperCAmelCase__						=		checkpoint['encoder.norm_out.weight']
						UpperCAmelCase__						=		checkpoint['encoder.norm_out.bias']

						UpperCAmelCase__						=		checkpoint['encoder.conv_in.weight']
						UpperCAmelCase__						=		checkpoint['encoder.conv_in.bias']
						UpperCAmelCase__						=		checkpoint['encoder.conv_out.weight']
						UpperCAmelCase__						=		checkpoint['encoder.conv_out.bias']

						UpperCAmelCase__						=		checkpoint['decoder.norm_out.weight']
						UpperCAmelCase__						=		checkpoint['decoder.norm_out.bias']

						UpperCAmelCase__						=		checkpoint['decoder.conv_in.weight']
						UpperCAmelCase__						=		checkpoint['decoder.conv_in.bias']
						UpperCAmelCase__						=		checkpoint['decoder.conv_out.weight']
						UpperCAmelCase__						=		checkpoint['decoder.conv_out.bias']

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

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

						for i in range(lowercase_			):
												UpperCAmelCase__						=		(i - 1) // (config['layers_per_block'] + 1)

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

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

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

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

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

						UpperCAmelCase__						=		[key for key in checkpoint if 'mid.block_1' in key]
						UpperCAmelCase__						=		[key for key in checkpoint if 'mid.block_2' in key]
						UpperCAmelCase__						=		[key for key in checkpoint if 'mid.attn_1' in key]

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

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

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

						for i in range(lowercase_			):
												UpperCAmelCase__						=		num_up_blocks - 1 - i

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

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

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

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

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

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

						return new_checkpoint


if __name__ == "__main__":
						UpperCamelCase_       :       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.""")

						UpperCamelCase_       :       List[Any]							   =		parser.parse_args()
						UpperCamelCase_       :       Optional[Any]							   =		torch.load(args.checkpoint_path)

						with open(args.config_file) as f:
												UpperCamelCase_       :       Union[str, Any]							   =		json.loads(f.read())

						# unet case
						UpperCamelCase_       :       Union[str, Any]							   =		{key.split(""".""")[0] for key in checkpoint.keys()}
						if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
												UpperCamelCase_       :       Union[str, 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_       :       Tuple							   =		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_       :       List[Any]							   =		UNetaDModel(**config)
												model.load_state_dict(converted_checkpoint)

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

												UpperCamelCase_       :       Optional[int]							   =		DDPMPipeline(unet=model, scheduler=scheduler)
												pipe.save_pretrained(args.dump_path)


"""simple docstring"""







from collections import deque


def   a__      (		UpperCAmelCase__       :			Tuple			)->	Optional[Any]:
						return input(UpperCAmelCase__			).strip().split(""" """			)


def   a__      (		UpperCAmelCase__       :			int		,			UpperCAmelCase__       :			int			)->	dict[int, list[int]]:
						UpperCAmelCase__						=		{}
						for i in range(UpperCAmelCase__			):
												UpperCAmelCase__						=		[]

						for e in range(UpperCAmelCase__			):
												UpperCAmelCase__	,      UpperCAmelCase__						=		(int(UpperCAmelCase__			) for i in _input(f'Edge {e + 1}: <node1> <node2> '			))
												graph[x].append(UpperCAmelCase__			)
						return graph


def   a__      (		UpperCAmelCase__       :			int		,			UpperCAmelCase__       :			int			)->	dict[int, list[int]]:
						UpperCAmelCase__						=		{}
						for i in range(UpperCAmelCase__			):
												UpperCAmelCase__						=		[]

						for e in range(UpperCAmelCase__			):
												UpperCAmelCase__	,      UpperCAmelCase__						=		(int(UpperCAmelCase__			) for i in _input(f'Edge {e + 1}: <node1> <node2> '			))
												graph[x].append(UpperCAmelCase__			)
												graph[y].append(UpperCAmelCase__			)
						return graph


def   a__      (		UpperCAmelCase__       :			int		,			UpperCAmelCase__       :			int			)->	dict[int, list[tuple[int, int]]]:
						UpperCAmelCase__						=		{}
						for i in range(UpperCAmelCase__			):
												UpperCAmelCase__						=		[]

						for e in range(UpperCAmelCase__			):
												UpperCAmelCase__	,      UpperCAmelCase__	,      UpperCAmelCase__						=		(int(UpperCAmelCase__			) for i in _input(f'Edge {e + 1}: <node1> <node2> <weight> '			))
												graph[x].append((y, w)			)
												graph[y].append((x, w)			)
						return graph


if __name__ == "__main__":
						UpperCamelCase_   ,						UpperCamelCase_       :       Any							   =		(int(i) for i in _input("""Number of nodes and edges: """))

						UpperCamelCase_       :       Union[str, Any]							   =		int(
						    _input(
						        """Press 1 or 2 or 3 \n"""
						        """1. Unweighted directed \n"""
						        """2. Unweighted undirected \n"""
						        """3. Weighted undirected \n"""
						    )[0]
						)

						UpperCamelCase_       :       Optional[int]							   =		{
						    1: initialize_unweighted_directed_graph,
						    2: initialize_unweighted_undirected_graph,
						    3: initialize_weighted_undirected_graph,
						}[graph_choice](n, m)


def   a__      (		UpperCAmelCase__       :			str		,			UpperCAmelCase__       :			Any			)->	Union[str, Any]:
						UpperCAmelCase__	,      UpperCAmelCase__						=		{s}, [s]
						print(UpperCAmelCase__			)
						while _s:
												UpperCAmelCase__						=		0
												for i in g[_s[-1]]:
																		if i not in vis:
																								_s.append(UpperCAmelCase__			)
																								vis.add(UpperCAmelCase__			)
																								UpperCAmelCase__						=		1
																								print(UpperCAmelCase__			)
																								break
												if not flag:
																		_s.pop()


def   a__      (		UpperCAmelCase__       :			Union[str, Any]		,			UpperCAmelCase__       :			int			)->	Union[str, Any]:
						UpperCAmelCase__	,      UpperCAmelCase__						=		{s}, deque([s]			)
						print(UpperCAmelCase__			)
						while q:
												UpperCAmelCase__						=		q.popleft()
												for v in g[u]:
																		if v not in vis:
																								vis.add(UpperCAmelCase__			)
																								q.append(UpperCAmelCase__			)
																								print(UpperCAmelCase__			)


def   a__      (		UpperCAmelCase__       :			Optional[Any]		,			UpperCAmelCase__       :			Any			)->	Optional[Any]:
						UpperCAmelCase__	,      UpperCAmelCase__	,      UpperCAmelCase__						=		{s: 0}, set(), {s: 0}
						while True:
												if len(UpperCAmelCase__			) == len(UpperCAmelCase__			) - 1:
																		break
												UpperCAmelCase__						=		1_0_0_0_0_0
												for i in dist:
																		if i not in known and dist[i] < mini:
																								UpperCAmelCase__						=		dist[i]
																								UpperCAmelCase__						=		i
												known.add(UpperCAmelCase__			)
												for v in g[u]:
																		if v[0] not in known and dist[u] + v[1] < dist.get(v[0]		,			1_0_0_0_0_0			):
																								UpperCAmelCase__						=		dist[u] + v[1]
																								UpperCAmelCase__						=		u
						for i in dist:
												if i != s:
																		print(dist[i]			)


def   a__      (		UpperCAmelCase__       :			Any		,			UpperCAmelCase__       :			int=None		,			UpperCAmelCase__       :			List[str]=None			)->	Dict:
						if q is None:
												UpperCAmelCase__						=		[1]
						if ind is None:
												UpperCAmelCase__						=		[0] * (len(UpperCAmelCase__			) + 1)  # SInce oth Index is ignored
												for u in g:
																		for v in g[u]:
																								ind[v] += 1
												UpperCAmelCase__						=		deque()
												for i in g:
																		if ind[i] == 0:
																								q.append(UpperCAmelCase__			)
						if len(UpperCAmelCase__			) == 0:
												return
						UpperCAmelCase__						=		q.popleft()
						print(UpperCAmelCase__			)
						for w in g[v]:
												ind[w] -= 1
												if ind[w] == 0:
																		q.append(UpperCAmelCase__			)
						topo(UpperCAmelCase__		,			UpperCAmelCase__		,			UpperCAmelCase__			)


def   a__      (		)->	List[Any]:
						UpperCAmelCase__						=		input().strip()
						UpperCAmelCase__						=		[]
						for _ in range(UpperCAmelCase__			):
												a.append(map(UpperCAmelCase__		,			input().strip().split()			)			)
						return a, n


def   a__      (		UpperCAmelCase__       :			str			)->	str:
						((UpperCAmelCase__)	,      (UpperCAmelCase__))						=		a_and_n
						UpperCAmelCase__						=		list(UpperCAmelCase__			)
						UpperCAmelCase__						=		[[0] * n for i in range(UpperCAmelCase__			)]
						for k in range(UpperCAmelCase__			):
												for i in range(UpperCAmelCase__			):
																		for j in range(UpperCAmelCase__			):
																								if dist[i][j] > dist[i][k] + dist[k][j]:
																														UpperCAmelCase__						=		dist[i][k] + dist[k][j]
																														UpperCAmelCase__						=		k
						print(UpperCAmelCase__			)


def   a__      (		UpperCAmelCase__       :			Optional[int]		,			UpperCAmelCase__       :			int			)->	Optional[int]:
						UpperCAmelCase__	,      UpperCAmelCase__	,      UpperCAmelCase__						=		{s: 0}, set(), {s: 0}
						while True:
												if len(UpperCAmelCase__			) == len(UpperCAmelCase__			) - 1:
																		break
												UpperCAmelCase__						=		1_0_0_0_0_0
												for i in dist:
																		if i not in known and dist[i] < mini:
																								UpperCAmelCase__						=		dist[i]
																								UpperCAmelCase__						=		i
												known.add(UpperCAmelCase__			)
												for v in g[u]:
																		if v[0] not in known and v[1] < dist.get(v[0]		,			1_0_0_0_0_0			):
																								UpperCAmelCase__						=		v[1]
																								UpperCAmelCase__						=		u
						return dist


def   a__      (		)->	Union[str, Any]:
						UpperCAmelCase__	,      UpperCAmelCase__						=		map(UpperCAmelCase__		,			input().split(""" """			)			)
						UpperCAmelCase__						=		[]
						for _ in range(UpperCAmelCase__			):
												edges.append(map(UpperCAmelCase__		,			input().split(""" """			)			)			)
						return edges, n


def   a__      (		UpperCAmelCase__       :			Tuple			)->	int:
						# Sort edges on the basis of distance
						((UpperCAmelCase__)	,      (UpperCAmelCase__))						=		e_and_n
						e.sort(reverse=UpperCAmelCase__		,			key=lambda UpperCAmelCase__			: x[2]			)
						UpperCAmelCase__						=		[{i} for i in range(1		,			n + 1			)]
						while True:
												if len(UpperCAmelCase__			) == 1:
																		break
												print(UpperCAmelCase__			)
												UpperCAmelCase__						=		e.pop()
												for i in range(len(UpperCAmelCase__			)			):
																		if x[0] in s[i]:
																								break
												for j in range(len(UpperCAmelCase__			)			):
																		if x[1] in s[j]:
																								if i == j:
																														break
																								s[j].update(s[i]			)
																								s.pop(UpperCAmelCase__			)
																								break







def   a__      (		UpperCAmelCase__       :			Union[str, Any]			)->	Dict:
						UpperCAmelCase__						=		[]
						for node in graph:
												if not graph[node]:
																		isolated.append(UpperCAmelCase__			)
						return isolated

