




import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()






class 			A			(		unittest.TestCase		):
     """simple docstring"""

     @property
     def  __snake_case   (    self  :   Optional[int]			)				->       Optional[int]:
           lowerCamelCase__        =				1
           lowerCamelCase__        =				3
           lowerCamelCase__        =				(3_2, 3_2)

           lowerCamelCase__        =				floats_tensor((batch_size, num_channels) + sizes	,  rng=random.Random(0			)			).to(A__			)
           return image




     @property
     def  __snake_case   (    self  :   int			)				->       List[str]:
           torch.manual_seed(0			)
           lowerCamelCase__        =				UNetaDModel(
               block_out_channels=(3_2, 6_4)	,  layers_per_block=2	,  sample_size=3_2	,  in_channels=6	,  out_channels=3	,  down_block_types=('DownBlock2D', 'AttnDownBlock2D')	,  up_block_types=('AttnUpBlock2D', 'UpBlock2D')	,  )
           return model




     @property
     def  __snake_case   (    self  :   List[Any]			)				->       Tuple:
           torch.manual_seed(0			)
           lowerCamelCase__        =				VQModel(
               block_out_channels=[3_2, 6_4]	,  in_channels=3	,  out_channels=3	,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']	,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']	,  latent_channels=3	,  )
           return model




     def  __snake_case   (    self  :   Optional[Any]			)				->       Optional[Any]:
           lowerCamelCase__        =				'cpu'
           lowerCamelCase__        =				self.dummy_uncond_unet
           lowerCamelCase__        =				DDIMScheduler()
           lowerCamelCase__        =				self.dummy_vq_model

           lowerCamelCase__        =				LDMSuperResolutionPipeline(unet=A__	,  vqvae=A__	,  scheduler=A__			)
           ldm.to(A__			)
           ldm.set_progress_bar_config(disable=A__			)

           lowerCamelCase__        =				self.dummy_image.to(A__			)

           lowerCamelCase__        =				torch.Generator(device=A__			).manual_seed(0			)
           lowerCamelCase__        =				ldm(image=A__	,  generator=A__	,  num_inference_steps=2	,  output_type='numpy'			).images

           lowerCamelCase__        =				image[0, -3:, -3:, -1]

           assert image.shape == (1, 6_4, 6_4, 3)
           lowerCamelCase__        =				np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]			)

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




     @unittest.skipIf(torch_device != 'cuda'	,  'This test requires a GPU'			)
     def  __snake_case   (    self  :   Dict			)				->       Dict:
           lowerCamelCase__        =				self.dummy_uncond_unet
           lowerCamelCase__        =				DDIMScheduler()
           lowerCamelCase__        =				self.dummy_vq_model

           # put models in fp16
           lowerCamelCase__        =				unet.half()
           lowerCamelCase__        =				vqvae.half()

           lowerCamelCase__        =				LDMSuperResolutionPipeline(unet=A__	,  vqvae=A__	,  scheduler=A__			)
           ldm.to(A__			)
           ldm.set_progress_bar_config(disable=A__			)

           lowerCamelCase__        =				self.dummy_image.to(A__			)

           lowerCamelCase__        =				ldm(A__	,  num_inference_steps=2	,  output_type='numpy'			).images

           assert image.shape == (1, 6_4, 6_4, 3)






@slow
@require_torch
class 			A			(		unittest.TestCase		):
     """simple docstring"""

     def  __snake_case   (    self  :   str			)				->       Optional[int]:
           lowerCamelCase__        =				load_image(
               'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
               '/vq_diffusion/teddy_bear_pool.png'			)
           lowerCamelCase__        =				init_image.resize((6_4, 6_4)	,  resample=PIL_INTERPOLATION['lanczos']			)

           lowerCamelCase__        =				LDMSuperResolutionPipeline.from_pretrained('duongna/ldm-super-resolution'	,  device_map='auto'			)
           ldm.set_progress_bar_config(disable=A__			)

           lowerCamelCase__        =				torch.manual_seed(0			)
           lowerCamelCase__        =				ldm(image=A__	,  generator=A__	,  num_inference_steps=2_0	,  output_type='numpy'			).images

           lowerCamelCase__        =				image[0, -3:, -3:, -1]

           assert image.shape == (1, 2_5_6, 2_5_6, 3)
           lowerCamelCase__        =				np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]			)

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





def 			lowerCAmelCase_			(  lowerCamelCase:       int     ,				lowerCamelCase:       list[tuple[int, int, int]]						)					->			list[tuple[int, int, int]]:


      '''simple docstring'''




      lowerCamelCase__        =				sorted(lowerCamelCase     ,				key=lambda lowerCamelCase						: edge[2]						)

      lowerCamelCase__        =				list(range(lowerCamelCase						)						)

      def find_parent(lowerCamelCase:       int						):
            if i != parent[i]:
                  lowerCamelCase__        =				find_parent(parent[i]						)
            return parent[i]

      lowerCamelCase__        =				0
      lowerCamelCase__        =				[]

      for edge in edges:
            lowerCamelCase__        =				find_parent(edge[0]						)
            lowerCamelCase__        =				find_parent(edge[1]						)
            if parent_a != parent_b:
                  minimum_spanning_tree_cost += edge[2]
                  minimum_spanning_tree.append(lowerCamelCase						)
                  lowerCamelCase__        =				parent_b

      return minimum_spanning_tree


if __name__ == "__main__":  # pragma: no cover
      __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    :   Tuple       =list(map(int, input().strip().split()))
      __SCREAMING_SNAKE_CASE    :   Optional[Any]       =[]

      for _ in range(num_edges):
            __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    :   Optional[int]       =(int(x) for x in input().strip().split())
            edges.append((nodea, nodea, cost))

      kruskal(num_nodes, edges)