


import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class 			lowerCamelCase_					(    _SCREAMING_SNAKE_CASE   ,		unittest.TestCase    ):
							_lowerCamelCase				: Optional[int]       =					UnCLIPPipeline
							_lowerCamelCase				: Optional[Any]       =					TEXT_TO_IMAGE_PARAMS - {
							    """negative_prompt""",
							    """height""",
							    """width""",
							    """negative_prompt_embeds""",
							    """guidance_scale""",
							    """prompt_embeds""",
							    """cross_attention_kwargs""",
							}
							_lowerCamelCase				: List[Any]       =					TEXT_TO_IMAGE_BATCH_PARAMS
							_lowerCamelCase				: str       =					[
							    """generator""",
							    """return_dict""",
							    """prior_num_inference_steps""",
							    """decoder_num_inference_steps""",
							    """super_res_num_inference_steps""",
							]
							_lowerCamelCase				: Optional[Any]       =					False





							@property
							def   __magic_name__      (							self    ):
								return 32





							@property
							def   __magic_name__      (							self    ):
								return 32





							@property
							def   __magic_name__      (							self    ):
								return self.time_input_dim





							@property
							def   __magic_name__      (							self    ):
								return self.time_input_dim * 4





							@property
							def   __magic_name__      (							self    ):
								return 100





							@property
							def   __magic_name__      (							self    ):
								a_     			=   CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )
								return tokenizer





							@property
							def   __magic_name__      (							self    ):
								torch.manual_seed(0    )
								a_     			=   CLIPTextConfig(
								    bos_token_id=0			,       eos_token_id=2			,       hidden_size=self.text_embedder_hidden_size			,       projection_dim=self.text_embedder_hidden_size			,       intermediate_size=37			,       layer_norm_eps=1E-05			,       num_attention_heads=4			,       num_hidden_layers=5			,       pad_token_id=1			,       vocab_size=1000			,       )
								return CLIPTextModelWithProjection(_SCREAMING_SNAKE_CASE    )





							@property
							def   __magic_name__      (							self    ):
								torch.manual_seed(0    )

								a_     			=   {
								    """num_attention_heads""": 2,
								    """attention_head_dim""": 12,
								    """embedding_dim""": self.text_embedder_hidden_size,
								    """num_layers""": 1,
								}

								a_     			=   PriorTransformer(**_SCREAMING_SNAKE_CASE    )
								return model





							@property
							def   __magic_name__      (							self    ):
								torch.manual_seed(0    )

								a_     			=   {
								    """clip_embeddings_dim""": self.text_embedder_hidden_size,
								    """time_embed_dim""": self.time_embed_dim,
								    """cross_attention_dim""": self.cross_attention_dim,
								}

								a_     			=   UnCLIPTextProjModel(**_SCREAMING_SNAKE_CASE    )
								return model





							@property
							def   __magic_name__      (							self    ):
								torch.manual_seed(0    )

								a_     			=   {
								    """sample_size""": 32,
								    # RGB in channels
								    """in_channels""": 3,
								    # Out channels is double in channels because predicts mean and variance
								    """out_channels""": 6,
								    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
								    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
								    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
								    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
								    """layers_per_block""": 1,
								    """cross_attention_dim""": self.cross_attention_dim,
								    """attention_head_dim""": 4,
								    """resnet_time_scale_shift""": """scale_shift""",
								    """class_embed_type""": """identity""",
								}

								a_     			=   UNetaDConditionModel(**_SCREAMING_SNAKE_CASE    )
								return model





							@property
							def   __magic_name__      (							self    ):
								return {
								    "sample_size": 64,
								    "layers_per_block": 1,
								    "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
								    "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
								    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
								    "in_channels": 6,
								    "out_channels": 3,
								}





							@property
							def   __magic_name__      (							self    ):
								torch.manual_seed(0    )

								a_     			=   UNetaDModel(**self.dummy_super_res_kwargs    )
								return model





							@property
							def   __magic_name__      (							self    ):
								# seeded differently to get different unet than `self.dummy_super_res_first`
								torch.manual_seed(1    )

								a_     			=   UNetaDModel(**self.dummy_super_res_kwargs    )
								return model





							def   __magic_name__      (							self    ):
								a_     			=   self.dummy_prior
								a_     			=   self.dummy_decoder
								a_     			=   self.dummy_text_proj
								a_     			=   self.dummy_text_encoder
								a_     			=   self.dummy_tokenizer
								a_     			=   self.dummy_super_res_first
								a_     			=   self.dummy_super_res_last

								a_     			=   UnCLIPScheduler(
								    variance_type="""fixed_small_log"""			,       prediction_type="""sample"""			,       num_train_timesteps=1000			,       clip_sample_range=5.0			,       )

								a_     			=   UnCLIPScheduler(
								    variance_type="""learned_range"""			,       prediction_type="""epsilon"""			,       num_train_timesteps=1000			,       )

								a_     			=   UnCLIPScheduler(
								    variance_type="""fixed_small_log"""			,       prediction_type="""epsilon"""			,       num_train_timesteps=1000			,       )

								a_     			=   {
								    """prior""": prior,
								    """decoder""": decoder,
								    """text_proj""": text_proj,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """super_res_first""": super_res_first,
								    """super_res_last""": super_res_last,
								    """prior_scheduler""": prior_scheduler,
								    """decoder_scheduler""": decoder_scheduler,
								    """super_res_scheduler""": super_res_scheduler,
								}

								return components





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE=0    ):
								if str(_SCREAMING_SNAKE_CASE    ).startswith("""mps"""    ):
									a_     			=   torch.manual_seed(_SCREAMING_SNAKE_CASE    )
								else:
									a_     			=   torch.Generator(device=_SCREAMING_SNAKE_CASE    ).manual_seed(_SCREAMING_SNAKE_CASE    )
								a_     			=   {
								    """prompt""": """horse""",
								    """generator""": generator,
								    """prior_num_inference_steps""": 2,
								    """decoder_num_inference_steps""": 2,
								    """super_res_num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}
								return inputs





							def   __magic_name__      (							self    ):
								a_     			=   """cpu"""

								a_     			=   self.get_dummy_components()

								a_     			=   self.pipeline_class(**_SCREAMING_SNAKE_CASE    )
								a_     			=   pipe.to(_SCREAMING_SNAKE_CASE    )

								pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

								a_     			=   pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE    )    )
								a_     			=   output.images

								a_     			=   pipe(
								    **self.get_dummy_inputs(_SCREAMING_SNAKE_CASE    )			,       return_dict=_SCREAMING_SNAKE_CASE			,       )[0]

								a_     			=   image[0, -3:, -3:, -1]
								a_     			=   image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)

								a_     			=   np.array(
								    [
								        0.9_9_9_7,
								        0.9_9_8_8,
								        0.0_0_2_8,
								        0.9_9_9_7,
								        0.9_9_8_4,
								        0.9_9_6_5,
								        0.0_0_2_9,
								        0.9_9_8_6,
								        0.0_0_2_5,
								    ]    )

								assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1E-2





							def   __magic_name__      (							self    ):
								a_     			=   torch.device("""cpu"""    )

								class 			lowerCamelCase_					:
															_lowerCamelCase				: Optional[int]       =					1







								a_     			=   self.get_dummy_components()

								a_     			=   self.pipeline_class(**_SCREAMING_SNAKE_CASE    )
								a_     			=   pipe.to(_SCREAMING_SNAKE_CASE    )

								a_     			=   components["""prior"""]
								a_     			=   components["""decoder"""]
								a_     			=   components["""super_res_first"""]
								a_     			=   components["""tokenizer"""]
								a_     			=   components["""text_encoder"""]

								a_     			=   torch.Generator(device=_SCREAMING_SNAKE_CASE    ).manual_seed(0    )
								a_     			=   prior.dtype
								a_     			=   1

								a_     			=   (batch_size, prior.config.embedding_dim)
								a_     			=   pipe.prepare_latents(
								    _SCREAMING_SNAKE_CASE			,       dtype=_SCREAMING_SNAKE_CASE			,       device=_SCREAMING_SNAKE_CASE			,       generator=_SCREAMING_SNAKE_CASE			,       latents=_SCREAMING_SNAKE_CASE			,       scheduler=DummyScheduler()    )
								a_     			=   (batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
								a_     			=   pipe.prepare_latents(
								    _SCREAMING_SNAKE_CASE			,       dtype=_SCREAMING_SNAKE_CASE			,       device=_SCREAMING_SNAKE_CASE			,       generator=_SCREAMING_SNAKE_CASE			,       latents=_SCREAMING_SNAKE_CASE			,       scheduler=DummyScheduler()    )

								a_     			=   (
								    batch_size,
								    super_res_first.config.in_channels // 2,
								    super_res_first.config.sample_size,
								    super_res_first.config.sample_size,
								)
								a_     			=   pipe.prepare_latents(
								    _SCREAMING_SNAKE_CASE			,       dtype=_SCREAMING_SNAKE_CASE			,       device=_SCREAMING_SNAKE_CASE			,       generator=_SCREAMING_SNAKE_CASE			,       latents=_SCREAMING_SNAKE_CASE			,       scheduler=DummyScheduler()    )

								pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

								a_     			=   """this is a prompt example"""

								a_     			=   torch.Generator(device=_SCREAMING_SNAKE_CASE    ).manual_seed(0    )
								a_     			=   pipe(
								    [prompt]			,       generator=_SCREAMING_SNAKE_CASE			,       prior_num_inference_steps=2			,       decoder_num_inference_steps=2			,       super_res_num_inference_steps=2			,       prior_latents=_SCREAMING_SNAKE_CASE			,       decoder_latents=_SCREAMING_SNAKE_CASE			,       super_res_latents=_SCREAMING_SNAKE_CASE			,       output_type="""np"""			,       )
								a_     			=   output.images

								a_     			=   tokenizer(
								    _SCREAMING_SNAKE_CASE			,       padding="""max_length"""			,       max_length=tokenizer.model_max_length			,       return_tensors="""pt"""			,       )
								a_     			=   text_encoder(text_inputs.input_ids    )
								a_     			=   text_inputs.attention_mask

								a_     			=   torch.Generator(device=_SCREAMING_SNAKE_CASE    ).manual_seed(0    )
								a_     			=   pipe(
								    generator=_SCREAMING_SNAKE_CASE			,       prior_num_inference_steps=2			,       decoder_num_inference_steps=2			,       super_res_num_inference_steps=2			,       prior_latents=_SCREAMING_SNAKE_CASE			,       decoder_latents=_SCREAMING_SNAKE_CASE			,       super_res_latents=_SCREAMING_SNAKE_CASE			,       text_model_output=_SCREAMING_SNAKE_CASE			,       text_attention_mask=_SCREAMING_SNAKE_CASE			,       output_type="""np"""			,       )[0]

								# make sure passing text embeddings manually is identical
								assert np.abs(image - image_from_text    ).max() < 1E-4





							@skip_mps
							def   __magic_name__      (							self    ):
								a_     			=   torch_device == """cpu"""

								self._test_attention_slicing_forward_pass(test_max_difference=_SCREAMING_SNAKE_CASE			,       expected_max_diff=0.0_1    )





							@skip_mps
							def   __magic_name__      (							self    ):
								a_     			=   torch_device == """cpu"""
								a_     			=   True
								a_     			=   [
								    """prior_num_inference_steps""",
								    """decoder_num_inference_steps""",
								    """super_res_num_inference_steps""",
								]

								self._test_inference_batch_single_identical(
								    test_max_difference=_SCREAMING_SNAKE_CASE			,       relax_max_difference=_SCREAMING_SNAKE_CASE			,       additional_params_copy_to_batched_inputs=_SCREAMING_SNAKE_CASE			,       )





							def   __magic_name__      (							self    ):
								a_     			=   [
								    """prior_num_inference_steps""",
								    """decoder_num_inference_steps""",
								    """super_res_num_inference_steps""",
								]

								if torch_device == "mps":
									# TODO: MPS errors with larger batch sizes
									a_     			=   [2, 3]
									self._test_inference_batch_consistent(
									    batch_sizes=_SCREAMING_SNAKE_CASE			,       additional_params_copy_to_batched_inputs=_SCREAMING_SNAKE_CASE			,       )
								else:
									self._test_inference_batch_consistent(
									    additional_params_copy_to_batched_inputs=_SCREAMING_SNAKE_CASE    )





							@skip_mps
							def   __magic_name__      (							self    ):
								return super().test_dict_tuple_outputs_equivalent()





							@skip_mps
							def   __magic_name__      (							self    ):
								return super().test_save_load_local()





							@skip_mps
							def   __magic_name__      (							self    ):
								return super().test_save_load_optional_components()







@nightly
class 			lowerCamelCase_					(    unittest.TestCase    ):





							def   __magic_name__      (							self    ):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()





							def   __magic_name__      (							self    ):
								a_     			=   load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/unclip/karlo_v1_alpha_horse_cpu.npy"""    )

								a_     			=   UnCLIPPipeline.from_pretrained("""kakaobrain/karlo-v1-alpha"""    )
								pipeline.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

								a_     			=   torch.manual_seed(0    )
								a_     			=   pipeline(
								    """horse"""			,       num_images_per_prompt=1			,       generator=_SCREAMING_SNAKE_CASE			,       output_type="""np"""			,       )

								a_     			=   output.images[0]

								assert image.shape == (256, 256, 3)
								assert np.abs(expected_image - image    ).max() < 1E-1







@slow
@require_torch_gpu
class 			lowerCamelCase_					(    unittest.TestCase    ):





							def   __magic_name__      (							self    ):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()





							def   __magic_name__      (							self    ):
								a_     			=   load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/unclip/karlo_v1_alpha_horse_fp16.npy"""    )

								a_     			=   UnCLIPPipeline.from_pretrained("""kakaobrain/karlo-v1-alpha"""			,       torch_dtype=torch.floataa    )
								a_     			=   pipeline.to(_SCREAMING_SNAKE_CASE    )
								pipeline.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )

								a_     			=   torch.Generator(device="""cpu"""    ).manual_seed(0    )
								a_     			=   pipeline(
								    """horse"""			,       generator=_SCREAMING_SNAKE_CASE			,       output_type="""np"""			,       )

								a_     			=   output.images[0]

								assert image.shape == (256, 256, 3)

								assert_mean_pixel_difference(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    )





							def   __magic_name__      (							self    ):
								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								a_     			=   UnCLIPPipeline.from_pretrained("""kakaobrain/karlo-v1-alpha"""			,       torch_dtype=torch.floataa    )
								a_     			=   pipe.to(_SCREAMING_SNAKE_CASE    )
								pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE    )
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								a_     			=   pipe(
								    """horse"""			,       num_images_per_prompt=1			,       prior_num_inference_steps=2			,       decoder_num_inference_steps=2			,       super_res_num_inference_steps=2			,       output_type="""np"""			,       )

								a_     			=   torch.cuda.max_memory_allocated()
								# make sure that less than 7 GB is allocated
								assert mem_bytes < 7 * 10**9



from collections import deque

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      Dict	)     ->	Tuple:



	"""simple docstring"""






	return input(UpperCamelCase	).strip().split(""" """	)

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      int     ,					UpperCamelCase		:      int	)     ->	dict[int, list[int]]:



	"""simple docstring"""






	a_     			=   {}
	for i in range(UpperCamelCase	):
		a_     			=   []

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

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      int     ,					UpperCamelCase		:      int	)     ->	dict[int, list[int]]:



	"""simple docstring"""






	a_     			=   {}
	for i in range(UpperCamelCase	):
		a_     			=   []

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

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      int     ,					UpperCamelCase		:      int	)     ->	dict[int, list[tuple[int, int]]]:



	"""simple docstring"""






	a_     			=   {}
	for i in range(UpperCamelCase	):
		a_     			=   []

	for e in range(UpperCamelCase	):
		a_			, a_			, a_     			=   (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__":
			_A     ,				_A							     =       (int(i) for i in _input('Number of nodes and edges: '))

			_A							     =       int(
			    _input(
			        'Press 1 or 2 or 3 \n'
			        '1. Unweighted directed \n'
			        '2. Unweighted undirected \n'
			        '3. Weighted undirected \n'
			    )[0]
			)

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

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      Tuple     ,					UpperCamelCase		:      Tuple	)     ->	List[Any]:



	"""simple docstring"""






	a_			, a_     			=   {s}, [s]
	print(UpperCamelCase	)
	while _s:
		a_     			=   0
		for i in g[_s[-1]]:
			if i not in vis:
				_s.append(UpperCamelCase	)
				vis.add(UpperCamelCase	)
				a_     			=   1
				print(UpperCamelCase	)
				break
		if not flag:
			_s.pop()

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      Tuple     ,					UpperCamelCase		:      int	)     ->	int:



	"""simple docstring"""






	a_			, a_     			=   {s}, deque([s]	)
	print(UpperCamelCase	)
	while q:
		a_     			=   q.popleft()
		for v in g[u]:
			if v not in vis:
				vis.add(UpperCamelCase	)
				q.append(UpperCamelCase	)
				print(UpperCamelCase	)

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      int     ,					UpperCamelCase		:      Any	)     ->	Union[str, Any]:



	"""simple docstring"""






	a_			, a_			, a_     			=   {s: 0}, set(), {s: 0}
	while True:
		if len(UpperCamelCase	) == len(UpperCamelCase	) - 1:
			break
		a_     			=   10_0000
		for i in dist:
			if i not in known and dist[i] < mini:
				a_     			=   dist[i]
				a_     			=   i
		known.add(UpperCamelCase	)
		for v in g[u]:
			if v[0] not in known and dist[u] + v[1] < dist.get(v[0]     ,					10_0000	):
				a_     			=   dist[u] + v[1]
				a_     			=   u
	for i in dist:
		if i != s:
			print(dist[i]	)

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      Dict     ,					UpperCamelCase		:      int=None     ,					UpperCamelCase		:      int=None	)     ->	Union[str, Any]:



	"""simple docstring"""






	if q is None:
		a_     			=   [1]
	if ind is None:
		a_     			=   [0] * (len(UpperCamelCase	) + 1)  # SInce oth Index is ignored
		for u in g:
			for v in g[u]:
				ind[v] += 1
		a_     			=   deque()
		for i in g:
			if ind[i] == 0:
				q.append(UpperCamelCase	)
	if len(UpperCamelCase	) == 0:
		return
	a_     			=   q.popleft()
	print(UpperCamelCase	)
	for w in g[v]:
		ind[w] -= 1
		if ind[w] == 0:
			q.append(UpperCamelCase	)
	topo(UpperCamelCase     ,					UpperCamelCase     ,					UpperCamelCase	)

def 			__SCREAMING_SNAKE_CASE		(		)     ->	List[Any]:



	"""simple docstring"""






	a_     			=   input().strip()
	a_     			=   []
	for _ in range(UpperCamelCase	):
		a.append(map(UpperCamelCase     ,					input().strip().split()	)	)
	return a, n

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      List[Any]	)     ->	List[str]:



	"""simple docstring"""






	((a_)			, (a_))     			=   a_and_n
	a_     			=   list(UpperCamelCase	)
	a_     			=   [[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]:
					a_     			=   dist[i][k] + dist[k][j]
					a_     			=   k
	print(UpperCamelCase	)

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      Dict     ,					UpperCamelCase		:      List[Any]	)     ->	str:



	"""simple docstring"""






	a_			, a_			, a_     			=   {s: 0}, set(), {s: 0}
	while True:
		if len(UpperCamelCase	) == len(UpperCamelCase	) - 1:
			break
		a_     			=   10_0000
		for i in dist:
			if i not in known and dist[i] < mini:
				a_     			=   dist[i]
				a_     			=   i
		known.add(UpperCamelCase	)
		for v in g[u]:
			if v[0] not in known and v[1] < dist.get(v[0]     ,					10_0000	):
				a_     			=   v[1]
				a_     			=   u
	return dist

def 			__SCREAMING_SNAKE_CASE		(		)     ->	int:



	"""simple docstring"""






	a_			, a_     			=   map(UpperCamelCase     ,					input().split(""" """	)	)
	a_     			=   []
	for _ in range(UpperCamelCase	):
		edges.append(map(UpperCamelCase     ,					input().split(""" """	)	)	)
	return edges, n

def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      List[str]	)     ->	List[str]:



	"""simple docstring"""






	((a_)			, (a_))     			=   e_and_n
	e.sort(reverse=UpperCamelCase     ,					key=lambda UpperCamelCase	: x[2]	)
	a_     			=   [{i} for i in range(1     ,					n + 1	)]
	while True:
		if len(UpperCamelCase	) == 1:
			break
		print(UpperCamelCase	)
		a_     			=   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 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      str	)     ->	Optional[Any]:



	"""simple docstring"""






	a_     			=   []
	for node in graph:
		if not graph[node]:
			isolated.append(UpperCamelCase	)
	return isolated