



import sys
from collections import defaultdict



class 							lowerCAmelCase_						:
       def __init__(     self			)	->						Union[str, Any]:
          UpperCamelCase       :    Any		      =      []
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_			)	->						List[str]:
          return self.node_position[vertex]
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						Dict:
          UpperCamelCase       :    Dict		      =      pos
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						Optional[Any]:


          if start > size // 2 - 1:
             return
          else:
             if 2 * start + 2 >= size:
                UpperCamelCase       :    int		      =      2 * start + 1
             else:
                if heap[2 * start + 1] < heap[2 * start + 2]:
                   UpperCamelCase       :    Dict		      =      2 * start + 1
                else:
                   UpperCamelCase       :    List[str]		      =      2 * start + 2
             if heap[smallest_child] < heap[start]:
                UpperCamelCase      ,	UpperCamelCase       :    List[str]		      =      heap[smallest_child], positions[smallest_child]
                UpperCamelCase      ,	UpperCamelCase       :    List[str]		      =      (
                    heap[start],
                    positions[start],
                )
                UpperCamelCase      ,	UpperCamelCase       :    Optional[Any]		      =      temp, tempa

                UpperCamelCase       :    str		      =      self.get_position(positions[smallest_child]			)
                self.set_position(
                    positions[smallest_child],     self.get_position(positions[start]			)			)
                self.set_position(positions[start],     __lowerCAmelCase			)

                self.top_to_bottom(__lowerCAmelCase,     __lowerCAmelCase,     __lowerCAmelCase,     __lowerCAmelCase			)
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						List[str]:
          UpperCamelCase       :    Optional[Any]		      =      position[index]

          while index != 0:
             UpperCamelCase       :    Any		      =      int((index - 2) / 2			) if index % 2 == 0 else int((index - 1) / 2			)

             if val < heap[parent]:
                UpperCamelCase       :    Dict		      =      heap[parent]
                UpperCamelCase       :    Optional[Any]		      =      position[parent]
                self.set_position(position[parent],     __lowerCAmelCase			)
             else:
                UpperCamelCase       :    Optional[Any]		      =      val
                UpperCamelCase       :    Any		      =      temp
                self.set_position(__lowerCAmelCase,     __lowerCAmelCase			)
                break
             UpperCamelCase       :    List[Any]		      =      parent
          else:
             UpperCamelCase       :    List[Any]		      =      val
             UpperCamelCase       :    Any		      =      temp
             self.set_position(__lowerCAmelCase,     0			)
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						Optional[int]:
          UpperCamelCase       :    Optional[int]		      =      len(__lowerCAmelCase			) // 2 - 1
          for i in range(__lowerCAmelCase,     -1,     -1			):
             self.top_to_bottom(__lowerCAmelCase,     __lowerCAmelCase,     len(__lowerCAmelCase			),     __lowerCAmelCase			)






       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						Optional[Any]:
          UpperCamelCase       :    Dict		      =      positions[0]
          UpperCamelCase       :    Dict		      =      sys.maxsize
          self.top_to_bottom(__lowerCAmelCase,     0,     len(__lowerCAmelCase			),     __lowerCAmelCase			)
          return temp






def 						UpperCamelCase      (  snake_case__			:       List[str]      )      ->	Dict:
   UpperCamelCase       :    List[Any]		      =      Heap()

   UpperCamelCase       :    List[str]		      =      [0] * len(_A      )
   UpperCamelCase       :    Tuple		      =      [-1] * len(_A      )  # Neighboring Tree Vertex of selected vertex
   # Minimum Distance of explored vertex with neighboring vertex of partial tree
   # formed in graph
   UpperCamelCase       :    str		      =      []  # Heap of Distance of vertices from their neighboring vertex
   UpperCamelCase       :    str		      =      []

   for vertex in range(len(_A      )      ):
      distance_tv.append(sys.maxsize      )
      positions.append(_A      )
      heap.node_position.append(_A      )

   UpperCamelCase       :    Optional[int]		      =      []
   UpperCamelCase       :    int		      =      1
   UpperCamelCase       :    Tuple		      =      sys.maxsize
   for neighbor, distance in adjacency_list[0]:
      UpperCamelCase       :    Any		      =      0
      UpperCamelCase       :    Dict		      =      distance
   heap.heapify(_A			,	_A      )

   for _ in range(1			,	len(_A      )      ):
      UpperCamelCase       :    int		      =      heap.delete_minimum(_A			,	_A      )
      if visited[vertex] == 0:
         tree_edges.append((nbr_tv[vertex], vertex)      )
         UpperCamelCase       :    Any		      =      1
         for neighbor, distance in adjacency_list[vertex]:
            if (
                visited[neighbor] == 0
                and distance < distance_tv[heap.get_position(_A      )]
            ):
               UpperCamelCase       :    Optional[Any]		      =      distance
               heap.bottom_to_top(
                   _A			,	heap.get_position(_A      )			,	_A			,	_A      )
               UpperCamelCase       :    Dict		      =      vertex
   return tree_edges


if __name__ == "__main__":  # pragma: no cover
    # < --------- Prims Algorithm --------- >
    __UpperCAmelCase			  =			int(input('''Enter number of edges: ''').strip())
    __UpperCAmelCase			  =			defaultdict(list)
    for _ in range(edges_number):
        __UpperCAmelCase			  =			[int(x) for x in input().strip().split()]
        adjacency_list[edge[0]].append([edge[1], edge[2]])
        adjacency_list[edge[1]].append([edge[0], edge[2]])
    print(prisms_algorithm(adjacency_list))




'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class 							a__(   lowerCAmelCase__					,		unittest.TestCase      ):


			'''simple docstring'''






			UpperCAmelCase_     :	List[str]						=			KandinskyImgaImgPipeline
			UpperCAmelCase_     :	Union[str, Any]						=			['''prompt''', '''image_embeds''', '''negative_image_embeds''', '''image''']
			UpperCAmelCase_     :	List[str]						=			[
			    '''prompt''',
			    '''negative_prompt''',
			    '''image_embeds''',
			    '''negative_image_embeds''',
			    '''image''',
			]
			UpperCAmelCase_     :	Dict						=			[
			    '''generator''',
			    '''height''',
			    '''width''',
			    '''strength''',
			    '''guidance_scale''',
			    '''negative_prompt''',
			    '''num_inference_steps''',
			    '''return_dict''',
			    '''guidance_scale''',
			    '''num_images_per_prompt''',
			    '''output_type''',
			    '''return_dict''',
			]
			UpperCAmelCase_     :	str						=			False



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return 32



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return 32



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return self.time_input_dim



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return self.time_input_dim * 4



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return 100



			@property
			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base""")
					return tokenizer



			@property
			def 				a_			(  self):




					"""simple docstring"""


					torch.manual_seed(0)
					lowerCAmelCase     =    MCLIPConfig(
					    numDims=self.cross_attention_dim			,       transformerDimensions=self.text_embedder_hidden_size			,       hidden_size=self.text_embedder_hidden_size			,       intermediate_size=37			,       num_attention_heads=4			,       num_hidden_layers=5			,       vocab_size=1005			,       )

					lowerCAmelCase     =    MultilingualCLIP(__lowerCAmelCase)
					lowerCAmelCase     =    text_encoder.eval()

					return text_encoder



			@property
			def 				a_			(  self):




					"""simple docstring"""


					torch.manual_seed(0)

					lowerCAmelCase     =    {
					    """in_channels""": 4,
					    # Out channels is double in channels because predicts mean and variance
					    """out_channels""": 8,
					    """addition_embed_type""": """text_image""",
					    """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,
					    """encoder_hid_dim""": self.text_embedder_hidden_size,
					    """encoder_hid_dim_type""": """text_image_proj""",
					    """cross_attention_dim""": self.cross_attention_dim,
					    """attention_head_dim""": 4,
					    """resnet_time_scale_shift""": """scale_shift""",
					    """class_embed_type""": None,
					}

					lowerCAmelCase     =    UNetaDConditionModel(**__lowerCAmelCase)
					return model



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return {
					    "block_out_channels": [32, 64],
					    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
					    "in_channels": 3,
					    "latent_channels": 4,
					    "layers_per_block": 1,
					    "norm_num_groups": 8,
					    "norm_type": "spatial",
					    "num_vq_embeddings": 12,
					    "out_channels": 3,
					    "up_block_types": [
					        "AttnUpDecoderBlock2D",
					        "UpDecoderBlock2D",
					    ],
					    "vq_embed_dim": 4,
					}



			@property
			def 				a_			(  self):




					"""simple docstring"""


					torch.manual_seed(0)
					lowerCAmelCase     =    VQModel(**self.dummy_movq_kwargs)
					return model



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    self.dummy_text_encoder
					lowerCAmelCase     =    self.dummy_tokenizer
					lowerCAmelCase     =    self.dummy_unet
					lowerCAmelCase     =    self.dummy_movq

					lowerCAmelCase     =    {
					    """num_train_timesteps""": 1000,
					    """beta_schedule""": """linear""",
					    """beta_start""": 0.00085,
					    """beta_end""": 0.012,
					    """clip_sample""": False,
					    """set_alpha_to_one""": False,
					    """steps_offset""": 0,
					    """prediction_type""": """epsilon""",
					    """thresholding""": False,
					}

					lowerCAmelCase     =    DDIMScheduler(**__lowerCAmelCase)

					lowerCAmelCase     =    {
					    """text_encoder""": text_encoder,
					    """tokenizer""": tokenizer,
					    """unet""": unet,
					    """scheduler""": scheduler,
					    """movq""": movq,
					}

					return components



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase=0):




					"""simple docstring"""


					lowerCAmelCase     =    floats_tensor((1, self.cross_attention_dim)			,       rng=random.Random(__lowerCAmelCase)).to(__lowerCAmelCase)
					lowerCAmelCase     =    floats_tensor((1, self.cross_attention_dim)			,       rng=random.Random(seed + 1)).to(__lowerCAmelCase)
					# create init_image
					lowerCAmelCase     =    floats_tensor((1, 3, 64, 64)			,       rng=random.Random(__lowerCAmelCase)).to(__lowerCAmelCase)
					lowerCAmelCase     =    image.cpu().permute(0			,       2			,       3			,       1)[0]
					lowerCAmelCase     =    Image.fromarray(np.uinta(__lowerCAmelCase)).convert("""RGB""").resize((256, 256))

					if str(__lowerCAmelCase).startswith("""mps"""):
							lowerCAmelCase     =    torch.manual_seed(__lowerCAmelCase)
					else:
							lowerCAmelCase     =    torch.Generator(device=__lowerCAmelCase).manual_seed(__lowerCAmelCase)
					lowerCAmelCase     =    {
					    """prompt""": """horse""",
					    """image""": init_image,
					    """image_embeds""": image_embeds,
					    """negative_image_embeds""": negative_image_embeds,
					    """generator""": generator,
					    """height""": 64,
					    """width""": 64,
					    """num_inference_steps""": 10,
					    """guidance_scale""": 7.0,
					    """strength""": 0.2,
					    """output_type""": """np""",
					}
					return inputs







			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    """cpu"""

					lowerCAmelCase     =    self.get_dummy_components()

					lowerCAmelCase     =    self.pipeline_class(**__lowerCAmelCase)
					lowerCAmelCase     =    pipe.to(__lowerCAmelCase)

					pipe.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase     =    pipe(**self.get_dummy_inputs(__lowerCAmelCase))
					lowerCAmelCase     =    output.images

					lowerCAmelCase     =    pipe(
					    **self.get_dummy_inputs(__lowerCAmelCase)			,       return_dict=__lowerCAmelCase			,       )[0]

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

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

					lowerCAmelCase     =    np.array(
					    [0.61474943, 0.6073539, 0.43308544, 0.5928269, 0.47493595, 0.46755973, 0.4613838, 0.45368797, 0.50119233])
					assert (
					    np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
					), f" expected_slice {expected_slice}, but got {image_slice.flatten()}"
					assert (
					    np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2
					), f" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"







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


			'''simple docstring'''






			def 				a_			(  self):




					"""simple docstring"""


					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()







			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    load_numpy(
					    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
					    """/kandinsky/kandinsky_img2img_frog.npy""")

					lowerCAmelCase     =    load_image(
					    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png""")
					lowerCAmelCase     =    """A red cartoon frog, 4k"""

					lowerCAmelCase     =    KandinskyPriorPipeline.from_pretrained(
					    """kandinsky-community/kandinsky-2-1-prior"""			,       torch_dtype=torch.floataa)
					pipe_prior.to(__lowerCAmelCase)

					lowerCAmelCase     =    KandinskyImgaImgPipeline.from_pretrained(
					    """kandinsky-community/kandinsky-2-1"""			,       torch_dtype=torch.floataa)
					lowerCAmelCase     =    pipeline.to(__lowerCAmelCase)

					pipeline.set_progress_bar_config(disable=__lowerCAmelCase)

					lowerCAmelCase     =    torch.Generator(device="""cpu""").manual_seed(0)
					lowerCAmelCase   ,	lowerCAmelCase     =    pipe_prior(
					    __lowerCAmelCase			,       generator=__lowerCAmelCase			,       num_inference_steps=5			,       negative_prompt=""""""			,       ).to_tuple()

					lowerCAmelCase     =    pipeline(
					    __lowerCAmelCase			,       image=__lowerCAmelCase			,       image_embeds=__lowerCAmelCase			,       negative_image_embeds=__lowerCAmelCase			,       generator=__lowerCAmelCase			,       num_inference_steps=100			,       height=768			,       width=768			,       strength=0.2			,       output_type="""np"""			,       )

					lowerCAmelCase     =    output.images[0]

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

					assert_mean_pixel_difference(__lowerCAmelCase			,       __lowerCAmelCase)




