'''simple docstring'''


def    _lowerCamelCase       ( lowerCamelCase_   :				int      ,	lowerCamelCase_   :				list[tuple[int, int, int]]  ):



     """simple docstring"""





     UpperCAmelCase_				:  Dict  = sorted(lowerCamelCase_      ,	key=lambda lowerCamelCase_  : edge[2]  )

     UpperCAmelCase_				:  List[str]  = list(range(lowerCamelCase_  )  )

     def find_parent(lowerCamelCase_   :				Optional[Any]  ):
          if i != parent[i]:
               UpperCAmelCase_				:  int  = find_parent(parent[i]  )
          return parent[i]

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

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

     return minimum_spanning_tree


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

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

 kruskal(num_nodes, edges)








_A       =					{
    "+": lambda x, y: x + y,
    "-": lambda x, y: x - y,
    "*": lambda x, y: x * y,
    "/": lambda x, y: x / y,
}



def 		lowercase_     (  A__						)				->				Union[str, Any]:
    """simple docstring"""

    return c.isdigit()



def 		lowercase_     (  A__						)				->				int:
    """simple docstring"""

    snake_case						=   []

    # iterate over the string in reverse order
    for c in expression.split()[::-1]:
        # push operand to stack
        if is_operand(A__						):
            stack.append(int(A__						)						)

        else:
            # pop values from stack can calculate the result
            # push the result onto the stack again
            snake_case						=   stack.pop()
            snake_case						=   stack.pop()
            stack.append(calc[c](A__					,						A__						)						)

    return stack.pop()


# Driver code
if __name__ == "__main__":
   _A       =					"+ 9 * 2 6"
   print(evaluate(test_expression))

   _A       =					"/ * 10 2 + 4 1 "
   print(evaluate(test_expression))

