
def     UpperCamelCase      (					__lowerCamelCase  :				int       ,      __lowerCamelCase  :				list[tuple[int, int, int]]					):
       snake_case :     List[str]           =   sorted(__lowerCamelCase       ,      key=lambda __lowerCamelCase					: edge[2]					)

       snake_case :     Any           =   list(range(__lowerCamelCase					)					)

       def find_parent(__lowerCamelCase  :				str					):
              if i != parent[i]:
                     snake_case :     List[Any]           =   find_parent(parent[i]					)
              return parent[i]

       snake_case :     List[Any]           =   0
       snake_case :     Optional[int]           =   []

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

       return minimum_spanning_tree


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

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

   kruskal(num_nodes, edges)







import platform
from argparse import ArgumentParser

import huggingface_hub
import pandas
import pyarrow

from datasets import __version__ as version
from datasets.commands import BaseDatasetsCLICommand


def     UpperCamelCase      (					__lowerCamelCase  :				int					):
       return EnvironmentCommand()






class 						UpperCAmelCase	(		A_				):



   @staticmethod
   def        _SCREAMING_SNAKE_CASE     (snake_case__	:      ArgumentParser				)	->			Any:


          '''simple docstring'''


          snake_case :     Optional[Any]           =   parser.add_parser("env"					,		help="Print relevant system environment info."				)
          download_parser.set_defaults(func=snake_case__				)



   def        _SCREAMING_SNAKE_CASE     (self	:      Dict				)	->			Optional[Any]:


          '''simple docstring'''


          snake_case :     List[str]           =   {
              "`datasets` version": version,
              "Platform": platform.platform(),
              "Python version": platform.python_version(),
              "Huggingface_hub version": huggingface_hub.__version__,
              "PyArrow version": pyarrow.__version__,
              "Pandas version": pandas.__version__,
          }

          print("\nCopy-and-paste the text below in your GitHub issue.\n"				)
          print(self.format_dict(snake_case__				)				)

          return info



   @staticmethod
   def        _SCREAMING_SNAKE_CASE     (snake_case__	:      Tuple				)	->			Any:


          '''simple docstring'''


          return "\n".join([f"""- {prop}: {val}""" for prop, val in d.items()]				) + "\n"





