'''simple docstring'''




# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ast
import difflib
from collections.abc import Mapping
from typing import Any, Callable, Dict

class      lowerCamelCase_     (_A   ):
      '''simple docstring'''

      pass

def      UpperCamelCase_							( _UpperCAmelCase  :				Dict      ,     _UpperCAmelCase  :				List[str]      ,     _UpperCAmelCase  :				Optional[Any]=None      ,     _UpperCAmelCase  :				List[Any]=False   )   ->   Tuple:


       """simple docstring"""







       try:
              _UpperCAmelCase					:  Optional[int]											=   ast.parse(A_   )
       except SyntaxError as e:
              print("The code generated by the agent is not valid.\n"      ,     A_   )
              return
       if state is None:
              _UpperCAmelCase					:  List[str]											=   {}
       _UpperCAmelCase					:  str											=   None
       for idx, node in enumerate(expression.body   ):
              try:
                     _UpperCAmelCase					:  Union[str, Any]											=   evaluate_ast(A_      ,     A_      ,     A_   )
              except InterpretorError as e:
                     _UpperCAmelCase					:  List[str]											=   F"""Evaluation of the code stopped at line {idx} before the end because of the following error"""
                     if chat_mode:
                            msg += (
                                F""". Copy paste the following error message and send it back to the agent:\nI get an error: \'{e}\'"""
                            )
                     else:
                            msg += F""":\n{e}"""
                     print(A_   )
                     break
              if line_result is not None:
                     _UpperCAmelCase					:  Dict											=   line_result

       return result

def      UpperCamelCase_							( _UpperCAmelCase  :				Optional[Any]      ,     _UpperCAmelCase  :				str      ,     _UpperCAmelCase  :				Optional[Any]   )   ->   Optional[int]:


       """simple docstring"""







       if isinstance(A_      ,     ast.Assign   ):
              # Assignement -> we evaluate the assignement which should update the state
              # We return the variable assigned as it may be used to determine the final result.
              return evaluate_assign(A_      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.Call   ):
              # Function call -> we return the value of the function call
              return evaluate_call(A_      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.Constant   ):
              # Constant -> just return the value
              return expression.value
       elif isinstance(A_      ,     ast.Dict   ):
              # Dict -> evaluate all keys and values
              _UpperCAmelCase					:  str											=   [evaluate_ast(A_      ,     A_      ,     A_   ) for k in expression.keys]
              _UpperCAmelCase					:  Dict											=   [evaluate_ast(A_      ,     A_      ,     A_   ) for v in expression.values]
              return dict(zip(A_      ,     A_   )   )
       elif isinstance(A_      ,     ast.Expr   ):
              # Expression -> evaluate the content
              return evaluate_ast(expression.value      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.For   ):
              # For loop -> execute the loop
              return evaluate_for(A_      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.FormattedValue   ):
              # Formatted value (part of f-string) -> evaluate the content and return
              return evaluate_ast(expression.value      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.If   ):
              # If -> execute the right branch
              return evaluate_if(A_      ,     A_      ,     A_   )
       elif hasattr(A_      ,     "Index"   ) and isinstance(A_      ,     ast.Index   ):
              return evaluate_ast(expression.value      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.JoinedStr   ):
              return "".join([str(evaluate_ast(A_      ,     A_      ,     A_   )   ) for v in expression.values]   )
       elif isinstance(A_      ,     ast.List   ):
              # List -> evaluate all elements
              return [evaluate_ast(A_      ,     A_      ,     A_   ) for elt in expression.elts]
       elif isinstance(A_      ,     ast.Name   ):
              # Name -> pick up the value in the state
              return evaluate_name(A_      ,     A_      ,     A_   )
       elif isinstance(A_      ,     ast.Subscript   ):
              # Subscript -> return the value of the indexing
              return evaluate_subscript(A_      ,     A_      ,     A_   )
       else:
              # For now we refuse anything else. Let's add things as we need them.
              raise InterpretorError(F"""{expression.__class__.__name__} is not supported."""   )

def      UpperCamelCase_							( _UpperCAmelCase  :				List[str]      ,     _UpperCAmelCase  :				Any      ,     _UpperCAmelCase  :				Union[str, Any]   )   ->   Optional[Any]:


       """simple docstring"""







       _UpperCAmelCase					:  int											=   assign.targets
       _UpperCAmelCase					:  Dict											=   evaluate_ast(assign.value      ,     A_      ,     A_   )

       if len(A_   ) == 1:
              _UpperCAmelCase					:  List[Any]											=   result
       else:
              if len(A_   ) != len(A_   ):
                     raise InterpretorError(F"""Expected {len(A_   )} values but got {len(A_   )}."""   )
              for var_name, r in zip(A_      ,     A_   ):
                     _UpperCAmelCase					:  int											=   r
       return result

def      UpperCamelCase_							( _UpperCAmelCase  :				Union[str, Any]      ,     _UpperCAmelCase  :				List[str]      ,     _UpperCAmelCase  :				Optional[int]   )   ->   str:


       """simple docstring"""







       if not isinstance(call.func      ,     ast.Name   ):
              raise InterpretorError(
                  F"""It is not permitted to evaluate other functions than the provided tools (tried to execute {call.func} of """
                  F"""type {type(call.func   )}."""   )
       _UpperCAmelCase					:  Optional[int]											=   call.func.id
       if func_name not in tools:
              raise InterpretorError(
                  F"""It is not permitted to evaluate other functions than the provided tools (tried to execute {call.func.id})."""   )

       _UpperCAmelCase					:  Any											=   tools[func_name]
       # Todo deal with args
       _UpperCAmelCase					:  Optional[int]											=   [evaluate_ast(A_      ,     A_      ,     A_   ) for arg in call.args]
       _UpperCAmelCase					:  Optional[Any]											=   {keyword.arg: evaluate_ast(keyword.value      ,     A_      ,     A_   ) for keyword in call.keywords}
       return func(*A_      ,     **A_   )

def      UpperCamelCase_							( _UpperCAmelCase  :				Dict      ,     _UpperCAmelCase  :				Optional[int]      ,     _UpperCAmelCase  :				Tuple   )   ->   Any:


       """simple docstring"""







       _UpperCAmelCase					:  str											=   evaluate_ast(subscript.slice      ,     A_      ,     A_   )
       _UpperCAmelCase					:  Any											=   evaluate_ast(subscript.value      ,     A_      ,     A_   )
       if isinstance(A_      ,     (list, tuple)   ):
              return value[int(A_   )]
       if index in value:
              return value[index]
       if isinstance(A_      ,     A_   ) and isinstance(A_      ,     A_   ):
              _UpperCAmelCase					:  str											=   difflib.get_close_matches(A_      ,     list(value.keys()   )   )
              if len(A_   ) > 0:
                     return value[close_matches[0]]

       raise InterpretorError(F"""Could not index {value} with \'{index}\'."""   )

def      UpperCamelCase_							( _UpperCAmelCase  :				Union[str, Any]      ,     _UpperCAmelCase  :				Optional[int]      ,     _UpperCAmelCase  :				Optional[Any]   )   ->   str:


       """simple docstring"""







       if name.id in state:
              return state[name.id]
       _UpperCAmelCase					:  int											=   difflib.get_close_matches(name.id      ,     list(state.keys()   )   )
       if len(A_   ) > 0:
              return state[close_matches[0]]
       raise InterpretorError(F"""The variable `{name.id}` is not defined."""   )

def      UpperCamelCase_							( _UpperCAmelCase  :				Tuple      ,     _UpperCAmelCase  :				List[str]      ,     _UpperCAmelCase  :				List[str]   )   ->   Any:


       """simple docstring"""







       if len(condition.ops   ) > 1:
              raise InterpretorError("Cannot evaluate conditions with multiple operators"   )

       _UpperCAmelCase					:  Dict											=   evaluate_ast(condition.left      ,     A_      ,     A_   )
       _UpperCAmelCase					:  Dict											=   condition.ops[0]
       _UpperCAmelCase					:  Dict											=   evaluate_ast(condition.comparators[0]      ,     A_      ,     A_   )

       if isinstance(A_      ,     ast.Eq   ):
              return left == right
       elif isinstance(A_      ,     ast.NotEq   ):
              return left != right
       elif isinstance(A_      ,     ast.Lt   ):
              return left < right
       elif isinstance(A_      ,     ast.LtE   ):
              return left <= right
       elif isinstance(A_      ,     ast.Gt   ):
              return left > right
       elif isinstance(A_      ,     ast.GtE   ):
              return left >= right
       elif isinstance(A_      ,     ast.Is   ):
              return left is right
       elif isinstance(A_      ,     ast.IsNot   ):
              return left is not right
       elif isinstance(A_      ,     ast.In   ):
              return left in right
       elif isinstance(A_      ,     ast.NotIn   ):
              return left not in right
       else:
              raise InterpretorError(F"""Operator not supported: {comparator}"""   )

def      UpperCamelCase_							( _UpperCAmelCase  :				Optional[int]      ,     _UpperCAmelCase  :				str      ,     _UpperCAmelCase  :				Any   )   ->   Dict:


       """simple docstring"""







       _UpperCAmelCase					:  Dict											=   None
       if evaluate_condition(if_statement.test      ,     A_      ,     A_   ):
              for line in if_statement.body:
                     _UpperCAmelCase					:  Tuple											=   evaluate_ast(A_      ,     A_      ,     A_   )
                     if line_result is not None:
                            _UpperCAmelCase					:  Optional[Any]											=   line_result
       else:
              for line in if_statement.orelse:
                     _UpperCAmelCase					:  Optional[int]											=   evaluate_ast(A_      ,     A_      ,     A_   )
                     if line_result is not None:
                            _UpperCAmelCase					:  Union[str, Any]											=   line_result
       return result


def      UpperCamelCase_							( _UpperCAmelCase  :				List[Any]      ,     _UpperCAmelCase  :				Dict      ,     _UpperCAmelCase  :				Optional[Any]   )   ->   str:


       """simple docstring"""







       _UpperCAmelCase					:  Optional[Any]											=   None
       _UpperCAmelCase					:  Union[str, Any]											=   evaluate_ast(for_loop.iter      ,     A_      ,     A_   )
       for counter in iterator:
              _UpperCAmelCase					:  Dict											=   counter
              for expression in for_loop.body:
                     _UpperCAmelCase					:  int											=   evaluate_ast(A_      ,     A_      ,     A_   )
                     if line_result is not None:
                            _UpperCAmelCase					:  Optional[int]											=   line_result
       return result


'''simple docstring'''




def      UpperCamelCase_							( _UpperCAmelCase  :				int      ,     _UpperCAmelCase  :				list[tuple[int, int, int]]   )   ->   list[tuple[int, int, int]]:


       """simple docstring"""







       _UpperCAmelCase					:  Optional[int]											=   sorted(_UpperCAmelCase      ,     key=lambda _UpperCAmelCase   : edge[2]   )

       _UpperCAmelCase					:  Optional[int]											=   list(range(_UpperCAmelCase   )   )

       def find_parent(_UpperCAmelCase  :				Dict   ):
              if i != parent[i]:
                     _UpperCAmelCase					:  Tuple											=   find_parent(parent[i]   )
              return parent[i]

       _UpperCAmelCase					:  Union[str, Any]											=   0
       _UpperCAmelCase					:  Dict											=   []

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

       return minimum_spanning_tree


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

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

  kruskal(num_nodes, edges)

