



UpperCAmelCase							=       {
    "kilogram": 1,
    "gram": pow(10, 3),
    "milligram": pow(10, 6),
    "metric-ton": pow(10, -3),
    "long-ton": 0.00_09_84_20_73,
    "short-ton": 0.00_11_02_31_22,
    "pound": 2.20_46_24_42_02,
    "stone": 0.15_74_73_17_28,
    "ounce": 35.2_73_99_07_23,
    "carrat": 5_000,
    "atomic-mass-unit": 6.022136652E26,
}

UpperCAmelCase							=       {
    "kilogram": 1,
    "gram": pow(10, -3),
    "milligram": pow(10, -6),
    "metric-ton": pow(10, 3),
    "long-ton": 10_16.0_46_08,
    "short-ton": 9_07.1_84,
    "pound": 0.45_35_92,
    "stone": 6.3_50_29,
    "ounce": 0.0_28_34_95,
    "carrat": 0.00_02,
    "atomic-mass-unit": 1.660540199E-27,
}

def       A_   (						__a  :					str			,		__a  :					str			,		__a  :					float		):

				"""simple docstring"""
				if to_type not in KILOGRAM_CHART or from_type not in WEIGHT_TYPE_CHART:
								a__					   =		(
								    F'''Invalid \'from_type\' or \'to_type\' value: {from_type!r}, {to_type!r}\n'''
								    F'''Supported values are: {", ".join(__a		)}'''
								)
								raise ValueError(__a		)
				return value * KILOGRAM_CHART[to_type] * WEIGHT_TYPE_CHART[from_type]


if __name__ == "__main__":
	import doctest

	doctest.testmod()



"""simple docstring"""







def        __lowerCAmelCase							(_UpperCamelCase			,    _UpperCamelCase						):
	__lowerCAmelCase     :		Any		     = sorted(_UpperCamelCase			,    key=lambda _UpperCamelCase						: edge[2]						)

	__lowerCAmelCase     :		Union[str, Any]		     = list(range(_UpperCamelCase						)						)

	def find_parent(_UpperCamelCase						):
		if i != parent[i]:
			__lowerCAmelCase     :		int		     = find_parent(parent[i]						)
		return parent[i]

	__lowerCAmelCase     :		Optional[Any]		     = 0
	__lowerCAmelCase     :		List[str]		     = []

	for edge in edges:
		__lowerCAmelCase     :		List[str]		     = find_parent(edge[0]						)
		__lowerCAmelCase     :		Optional[Any]		     = find_parent(edge[1]						)
		if parent_a != parent_b:
			minimum_spanning_tree_cost += edge[2]
			minimum_spanning_tree.append(_UpperCamelCase						)
			__lowerCAmelCase     :		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)