






from transformers import HfArgumentParser, PyTorchBenchmark, PyTorchBenchmarkArguments







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



					"""simple docstring"""
					__a				:	Union[str, Any]			=				HfArgumentParser(__A			)
					try:
										__a				:	Optional[int]			=				parser.parse_args_into_dataclasses()[0]
					except ValueError as e:
										__a				:	Union[str, Any]			=				"Arg --no_{0} is no longer used, please use --no-{0} instead."
										__a				:	Union[str, Any]			=				" ".join(str(__A			).split(" "			)[:-1]			)
										__a				:	Union[str, Any]			=				""
										__a				:	List[str]			=				eval(str(__A			).split(" "			)[-1]			)
										__a				:	Union[str, Any]			=				[]
										for arg in depreciated_args:
															# arg[2:] removes '--'
															if arg[2:] in PyTorchBenchmarkArguments.deprecated_args:
																				# arg[5:] removes '--no_'
																				full_error_msg += arg_error_msg.format(arg[5:]			)
															else:
																				wrong_args.append(__A			)
										if len(__A			) > 0:
															__a				:	str			=				full_error_msg + begin_error_msg + str(__A			)
										raise ValueError(__A			)

					__a				:	Tuple			=				PyTorchBenchmark(args=__A			)
					benchmark.run()


if __name__ == "__main__":
		main()













def 						a_      (__A							,					__A			)							->	list[tuple[int, int, int]]:



					"""simple docstring"""
					__a				:	str			=				sorted(__A							,					key=lambda __A			: edge[2]			)

					__a				:	int			=				list(range(__A			)			)

					def find_parent(__A			):
										if i != parent[i]:
															__a				:	Optional[Any]			=				find_parent(parent[i]			)
										return parent[i]

					__a				:	Any			=				0
					__a				:	Optional[int]			=				[]

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

					return minimum_spanning_tree


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

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

			kruskal(num_nodes, edges)





