




import sys
from typing import Tuple

import numpy as np
import torch
from PIL import Image
from torch import nn

from transformers.image_utils import PILImageResampling
from utils import img_tensorize






class 			A			:
     """simple docstring"""

     def __init__(    self  :   Any	,  A__  :   str	,  A__  :   Union[str, Any]=sys.maxsize			)				->       Optional[Any]:
           lowerCamelCase__        =				'bilinear'
           lowerCamelCase__        =				max_size
           lowerCamelCase__        =				short_edge_length




     def __call__(    self  :   Optional[int]	,  A__  :   Any			)				->       List[str]:
           lowerCamelCase__        =				[]
           for img in imgs:
                 lowerCamelCase__  ,		lowerCamelCase__        =				img.shape[:2]
                 # later: provide list and randomly choose index for resize
                 lowerCamelCase__        =				np.random.randint(self.short_edge_length[0]	,  self.short_edge_length[1] + 1			)
                 if size == 0:
                       return img
                 lowerCamelCase__        =				size * 1.0 / min(A__	,  A__			)
                 if h < w:
                       lowerCamelCase__  ,		lowerCamelCase__        =				size, scale * w
                 else:
                       lowerCamelCase__  ,		lowerCamelCase__        =				scale * h, size
                 if max(A__	,  A__			) > self.max_size:
                       lowerCamelCase__        =				self.max_size * 1.0 / max(A__	,  A__			)
                       lowerCamelCase__        =				newh * scale
                       lowerCamelCase__        =				neww * scale
                 lowerCamelCase__        =				int(neww + 0.5			)
                 lowerCamelCase__        =				int(newh + 0.5			)

                 if img.dtype == np.uinta:
                       lowerCamelCase__        =				Image.fromarray(A__			)
                       lowerCamelCase__        =				pil_image.resize((neww, newh)	,  PILImageResampling.BILINEAR			)
                       lowerCamelCase__        =				np.asarray(A__			)
                 else:
                       lowerCamelCase__        =				img.permute(2	,  0	,  1			).unsqueeze(0			)  # 3, 0, 1)  # hw(c) -> nchw
                       lowerCamelCase__        =				nn.functional.interpolate(
                           A__	,  (newh, neww)	,  mode=self.interp_method	,  align_corners=A__			).squeeze(0			)
                 img_augs.append(A__			)

           return img_augs






class 			A			:
     """simple docstring"""

     def __init__(    self  :   Union[str, Any]	,  A__  :   Optional[Any]			)				->       Dict:
           lowerCamelCase__        =				ResizeShortestEdge([cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST]	,  cfg.INPUT.MAX_SIZE_TEST			)
           lowerCamelCase__        =				cfg.INPUT.FORMAT
           lowerCamelCase__        =				cfg.SIZE_DIVISIBILITY
           lowerCamelCase__        =				cfg.PAD_VALUE
           lowerCamelCase__        =				cfg.INPUT.MAX_SIZE_TEST
           lowerCamelCase__        =				cfg.MODEL.DEVICE
           lowerCamelCase__        =				torch.tensor(cfg.MODEL.PIXEL_STD			).to(self.device			).view(len(cfg.MODEL.PIXEL_STD			)	,  1	,  1			)
           lowerCamelCase__        =				torch.tensor(cfg.MODEL.PIXEL_MEAN			).to(self.device			).view(len(cfg.MODEL.PIXEL_STD			)	,  1	,  1			)
           lowerCamelCase__        =				lambda A__			: (x - self.pixel_mean) / self.pixel_std




     def  __snake_case   (    self  :   Any	,  A__  :   List[str]			)				->       Any:
           lowerCamelCase__        =				tuple(max(A__			) for s in zip(*[img.shape for img in images]			)			)
           lowerCamelCase__        =				[im.shape[-2:] for im in images]
           lowerCamelCase__        =				[
               nn.functional.pad(
                   A__	,  [0, max_size[-1] - size[1], 0, max_size[-2] - size[0]]	,  value=self.pad_value	,  )
               for size, im in zip(A__	,  A__			)
           ]

           return torch.stack(A__			), torch.tensor(A__			)




     def __call__(    self  :   Dict	,  A__  :   List[Any]	,  A__  :   Union[str, Any]=False			)				->       List[Any]:
           with torch.no_grad():
                 if not isinstance(A__	,  A__			):
                       lowerCamelCase__        =				[images]
                 if single_image:
                       assert len(A__			) == 1
                 for i in range(len(A__			)			):
                       if isinstance(images[i]	,  torch.Tensor			):
                             images.insert(A__	,  images.pop(A__			).to(self.device			).float()			)
                       elif not isinstance(images[i]	,  torch.Tensor			):
                             images.insert(
                                 A__	,  torch.as_tensor(img_tensorize(images.pop(A__			)	,  input_format=self.input_format			)			)
                                 .to(self.device			)
                                 .float()	,  )
            # resize smallest edge
                 lowerCamelCase__        =				torch.tensor([im.shape[:2] for im in images]			)
                 lowerCamelCase__        =				self.aug(A__			)
                 # transpose images and convert to torch tensors
                 # images = [torch.as_tensor(i.astype("float32")).permute(2, 0, 1).to(self.device) for i in images]
                 # now normalize before pad to avoid useless arithmetic
                 lowerCamelCase__        =				[self.normalizer(A__			) for x in images]
                 # now pad them to do the following operations
                 lowerCamelCase__  ,		lowerCamelCase__        =				self.pad(A__			)
                 # Normalize

                 if self.size_divisibility > 0:
                       raise NotImplementedError()
                 # pad
                 lowerCamelCase__        =				torch.true_divide(A__	,  A__			)
                 if single_image:
                       return images[0], sizes[0], scales_yx[0]
                 else:
                       return images, sizes, scales_yx

def 			lowerCAmelCase_			(  lowerCamelCase:       List[str]     ,				lowerCamelCase:       Tuple						)					->			List[str]:


      '''simple docstring'''




      boxes[:, 0::2] *= scale_yx[:, 1]
      boxes[:, 1::2] *= scale_yx[:, 0]
      return boxes


def 			lowerCAmelCase_			(  lowerCamelCase:       Dict     ,				lowerCamelCase:       Tuple[int, int]						)					->			List[str]:


      '''simple docstring'''




      assert torch.isfinite(lowerCamelCase						).all(), "Box tensor contains infinite or NaN!"
      lowerCamelCase__  ,		lowerCamelCase__        =				box_size
      tensor[:, 0].clamp_(min=0     ,				max=lowerCamelCase						)
      tensor[:, 1].clamp_(min=0     ,				max=lowerCamelCase						)
      tensor[:, 2].clamp_(min=0     ,				max=lowerCamelCase						)
      tensor[:, 3].clamp_(min=0     ,				max=lowerCamelCase						)





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)