import sys
from collections import defaultdict
class 	_lowerCAmelCase		:







							def __init__(					self  :     Optional[int]		):
										lowerCamelCase    :Optional[int]    	=  []







							def 					snake_case	(					self  :     Optional[Any]						,       __snake_case  :     List[Any]		):
										return self.node_position[vertex]







							def 					snake_case	(					self  :     int						,       __snake_case  :     Union[str, Any]						,       __snake_case  :     List[Any]		):
										lowerCamelCase    :List[Any]    	=  pos







							def 					snake_case	(					self  :     int						,       __snake_case  :     Optional[int]						,       __snake_case  :     List[Any]						,       __snake_case  :     List[Any]						,       __snake_case  :     Tuple		):


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

																lowerCamelCase    :Optional[Any]    	=  self.get_position(positions[smallest_child]		)
																self.set_position(
																    positions[smallest_child]						,       self.get_position(positions[start]		)		)
																self.set_position(positions[start]						,       _UpperCamelCase		)

																self.top_to_bottom(_UpperCamelCase						,       _UpperCamelCase						,       _UpperCamelCase						,       _UpperCamelCase		)







							def 					snake_case	(					self  :     int						,       __snake_case  :     List[Any]						,       __snake_case  :     Union[str, Any]						,       __snake_case  :     List[Any]						,       __snake_case  :     int		):
										lowerCamelCase    :Optional[int]    	=  position[index]

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

													if val < heap[parent]:
																lowerCamelCase    :Any    	=  heap[parent]
																lowerCamelCase    :List[Any]    	=  position[parent]
																self.set_position(position[parent]						,       _UpperCamelCase		)
													else:
																lowerCamelCase    :Optional[Any]    	=  val
																lowerCamelCase    :Optional[int]    	=  temp
																self.set_position(_UpperCamelCase						,       _UpperCamelCase		)
																break
													lowerCamelCase    :str    	=  parent
										else:
													lowerCamelCase    :Tuple    	=  val
													lowerCamelCase    :Optional[int]    	=  temp
													self.set_position(_UpperCamelCase						,       0		)







							def 					snake_case	(					self  :     Any						,       __snake_case  :     Optional[int]						,       __snake_case  :     int		):
										lowerCamelCase    :Any    	=  len(_UpperCamelCase		) // 2 - 1
										for i in range(_UpperCamelCase						,       -1						,       -1		):
													self.top_to_bottom(_UpperCamelCase						,       _UpperCamelCase						,       len(_UpperCamelCase		)						,       _UpperCamelCase		)







							def 					snake_case	(					self  :     Union[str, Any]						,       __snake_case  :     Tuple						,       __snake_case  :     Dict		):
										lowerCamelCase    :Dict    	=  positions[0]
										lowerCamelCase    :Union[str, Any]    	=  sys.maxsize
										self.top_to_bottom(_UpperCamelCase						,       0						,       len(_UpperCamelCase		)						,       _UpperCamelCase		)
										return temp





def 			_lowerCamelCase       ( a_					:			List[Any]):
			lowerCamelCase    :int    	=  Heap()

			lowerCamelCase    :Dict    	=  [0] * len(__A)
			lowerCamelCase    :Optional[int]    	=  [-1] * len(__A)  # Neighboring Tree Vertex of selected vertex
			# Minimum Distance of explored vertex with neighboring vertex of partial tree
			# formed in graph
			lowerCamelCase    :List[Any]    	=  []  # Heap of Distance of vertices from their neighboring vertex
			lowerCamelCase    :Optional[int]    	=  []

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

			lowerCamelCase    :Optional[Any]    	=  []
			lowerCamelCase    :List[str]    	=  1
			lowerCamelCase    :Optional[int]    	=  sys.maxsize
			for neighbor, distance in adjacency_list[0]:
						lowerCamelCase    :Any    	=  0
						lowerCamelCase    :Optional[int]    	=  distance
			heap.heapify(__A    ,      __A)

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


if __name__ == "__main__":  # pragma: no cover
			# < --------- Prims Algorithm --------- >
			A__     =				int(input("""Enter number of edges: """).strip())
			A__     =				defaultdict(list)
			for _ in range(edges_number):
						A__     =				[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))






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     __snake_case    :
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase      , _UpperCamelCase=sys.maxsize   )      ->							Any:






              """simple docstring"""


              __snake_case       	=							"""bilinear"""
              __snake_case       	=							max_size
              __snake_case       	=							short_edge_length






       def __call__(		self      , _UpperCamelCase   )      ->							Optional[Any]:






              """simple docstring"""


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

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

              return img_augs






class     __snake_case    :
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase   )      ->							Union[str, Any]:






              """simple docstring"""


              __snake_case       	=							ResizeShortestEdge([cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST]      , cfg.INPUT.MAX_SIZE_TEST   )
              __snake_case       	=							cfg.INPUT.FORMAT
              __snake_case       	=							cfg.SIZE_DIVISIBILITY
              __snake_case       	=							cfg.PAD_VALUE
              __snake_case       	=							cfg.INPUT.MAX_SIZE_TEST
              __snake_case       	=							cfg.MODEL.DEVICE
              __snake_case       	=							torch.tensor(cfg.MODEL.PIXEL_STD   ).to(self.device   ).view(len(cfg.MODEL.PIXEL_STD   )      , 1      , 1   )
              __snake_case       	=							torch.tensor(cfg.MODEL.PIXEL_MEAN   ).to(self.device   ).view(len(cfg.MODEL.PIXEL_STD   )      , 1      , 1   )
              __snake_case       	=							lambda _UpperCamelCase   : (x - self.pixel_mean) / self.pixel_std


       def 			a		(		self      , _UpperCamelCase   )      ->							int:






              """simple docstring"""


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

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






       def __call__(		self      , _UpperCamelCase      , _UpperCamelCase=False   )      ->							Union[str, Any]:






              """simple docstring"""


              with torch.no_grad():
                     if not isinstance(_UpperCamelCase      , _UpperCamelCase   ):
                            __snake_case       	=							[images]
                     if single_image:
                            assert len(_UpperCamelCase   ) == 1
                     for i in range(len(_UpperCamelCase   )   ):
                            if isinstance(images[i]      , torch.Tensor   ):
                                   images.insert(_UpperCamelCase      , images.pop(_UpperCamelCase   ).to(self.device   ).float()   )
                            elif not isinstance(images[i]      , torch.Tensor   ):
                                   images.insert(
                                       _UpperCamelCase      , torch.as_tensor(img_tensorize(images.pop(_UpperCamelCase   )      , input_format=self.input_format   )   )
                                       .to(self.device   )
                                       .float()      , )
            # resize smallest edge
                     __snake_case       	=							torch.tensor([im.shape[:2] for im in images]   )
                     __snake_case       	=							self.aug(_UpperCamelCase   )
                     # 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
                     __snake_case       	=							[self.normalizer(_UpperCamelCase   ) for x in images]
                     # now pad them to do the following operations
                     __snake_case	,    __snake_case       	=							self.pad(_UpperCamelCase   )
                     # Normalize

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







def 						lowerCamelCase__      ( __A    :Union[str, Any]	,__A    :List[Any]		):


       """simple docstring"""




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







def 						lowerCamelCase__      ( __A    :Tuple	,__A    :Tuple[int, int]		):


       """simple docstring"""




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

