


"""simple docstring"""







def        a__			(							_UpperCamelCase						,      _UpperCamelCase			):





						"""simple docstring"""

						UpperCAmelCase__												=     sorted(UpperCamelCase__						,      key=lambda _UpperCamelCase			: edge[2]			)

						UpperCAmelCase__												=     list(range(UpperCamelCase__			)			)

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

						UpperCAmelCase__												=     0
						UpperCAmelCase__												=     []

						for edge in edges:
												UpperCAmelCase__												=     find_parent(edge[0]			)
												UpperCAmelCase__												=     find_parent(edge[1]			)
												if parent_a != parent_b:
																		minimum_spanning_tree_cost += edge[2]
																		minimum_spanning_tree.append(UpperCamelCase__			)
																		UpperCAmelCase__												=     parent_b

						return minimum_spanning_tree


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

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

						kruskal(num_nodes, edges)






import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
					import torch
class       UpperCamelCase_		(	unittest.TestCase				,	_lowerCamelCase       ):




					def 						lowerCAmelCase      (		self	)		->				str:
										_snake_case						=					load_tool('speech-to-text'	)
										self.tool.setup()




					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										_snake_case						=					self.tool(torch.ones(3000	)	)
										self.assertEqual(lowerCAmelCase_					,    ' you'	)






					def 						lowerCAmelCase      (		self	)		->				Optional[int]:
										_snake_case						=					self.tool(audio=torch.ones(3000	)	)
										self.assertEqual(lowerCAmelCase_					,    ' you'	)



