
"""simple docstring"""





def       __a	(						__lowerCamelCase,						__lowerCamelCase    ):
   UpperCAmelCase_   :   str     	=       sorted(__lowerCamelCase,						key=lambda __lowerCamelCase    : edge[2]    )

   UpperCAmelCase_   :   Union[str, Any]     	=       list(range(__lowerCamelCase    )    )

   def find_parent(__lowerCamelCase    ):
      if i != parent[i]:
         UpperCAmelCase_   :   str     	=       find_parent(parent[i]    )
      return parent[i]

   UpperCAmelCase_   :   Union[str, Any]     	=       0
   UpperCAmelCase_   :   Optional[Any]     	=       []

   for edge in edges:
      UpperCAmelCase_   :   Optional[int]     	=       find_parent(edge[0]    )
      UpperCAmelCase_   :   List[str]     	=       find_parent(edge[1]    )
      if parent_a != parent_b:
         minimum_spanning_tree_cost += edge[2]
         minimum_spanning_tree.append(__lowerCamelCase    )
         UpperCAmelCase_   :   Union[str, Any]     	=       parent_b

   return minimum_spanning_tree


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

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

    kruskal(num_nodes, edges)





import numpy as np
import PIL
import torch
import torchvision.transforms as T
import torchvision.transforms.functional as TF
from PIL import Image







def 						_snake_case		(     SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE=256					)							->   Optional[int]:

     """simple docstring"""







     _lowerCAmelCase :       Any	   =     min(img.size					)

     if s < target_image_size:
          raise ValueError(f'''min dim for image {s} < {target_image_size}'''					)

     _lowerCAmelCase :       Dict	   =     target_image_size / s
     _lowerCAmelCase :       Dict	   =     (round(r * img.size[1]					), round(r * img.size[0]					))
     _lowerCAmelCase :       Any	   =     TF.resize(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				interpolation=PIL.Image.LANCZOS					)
     _lowerCAmelCase :       str	   =     TF.center_crop(SCREAMING_SNAKE_CASE		,				output_size=2 * [target_image_size]					)
     _lowerCAmelCase :       int	   =     torch.unsqueeze(T.ToTensor()(SCREAMING_SNAKE_CASE					)		,				0					)
     return img







def 						_snake_case		(     SCREAMING_SNAKE_CASE					)							->   List[str]:

     """simple docstring"""







     _lowerCAmelCase :       List[Any]	   =     2.0 * x - 1.0
     return x







def 						_snake_case		(     SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE=True		,				SCREAMING_SNAKE_CASE="RGB"					)							->   int:

     """simple docstring"""







     _lowerCAmelCase :       Optional[int]	   =     x.detach().cpu()
     if process:
          _lowerCAmelCase :       List[Any]	   =     post_process_tensor(SCREAMING_SNAKE_CASE					)
     _lowerCAmelCase :       Optional[int]	   =     x.numpy()
     if process:
          _lowerCAmelCase :       List[Any]	   =     (255 * x).astype(np.uinta					)
     _lowerCAmelCase :       Optional[int]	   =     Image.fromarray(SCREAMING_SNAKE_CASE					)
     if not x.mode == mode:
          _lowerCAmelCase :       str	   =     x.convert(SCREAMING_SNAKE_CASE					)
     return x







def 						_snake_case		(     SCREAMING_SNAKE_CASE					)							->   Union[str, Any]:

     """simple docstring"""







     _lowerCAmelCase :       Any	   =     torch.clamp(SCREAMING_SNAKE_CASE		,				-1.0		,				1.0					)
     _lowerCAmelCase :       Any	   =     (x + 1.0) / 2.0
     _lowerCAmelCase :       List[Any]	   =     x.permute(1		,				2		,				0					)
     return x







def 						_snake_case		(     SCREAMING_SNAKE_CASE					)							->   Tuple:

     """simple docstring"""







     _lowerCAmelCase :       str	   =     post_process_tensor(x.squeeze()					)
     return x.permute(2		,				0		,				1					).unsqueeze(0					)






