


import random
import shutil
import tempfile
import unittest

import numpy as np

from transformers import TaTokenizer, TaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torch
from transformers.utils.import_utils import is_speech_available, is_torch_available


if is_torch_available():
			pass

if is_speech_available():
			from transformers import EncodecFeatureExtractor, MusicgenProcessor


snake_case__  				=			random.Random()
def 			__SCREAMING_SNAKE_CASE							(					lowercase__	:List[Any]   ,    lowercase__	:Optional[Any]=1.0   ,    lowercase__	:Dict=None   ,    lowercase__	:Any=None					)							->	List[str]:
						if rng is None:
												__magic_name__					:				List[str]				=   global_rng

						__magic_name__					:				Optional[Any]				=   []
						for batch_idx in range(shape[0]					):
												values.append([]					)
												for _ in range(shape[1]					):
																		values[-1].append(rng.random() * scale					)

						return values



@require_torch
@require_sentencepiece
class      snake_case__	(   unittest.TestCase	):
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				List[Any]				=   'facebook/musicgen-small'
										__magic_name__					:				Dict				=   tempfile.mkdtemp()
				def 			UpperCamelCase_    (	self  ,   **_UpperCAmelCase   ):




										"""simple docstring"""




										return TaTokenizer.from_pretrained(self.checkpoint  ,   **__SCREAMING_SNAKE_CASE   )
				def 			UpperCamelCase_    (	self  ,   **_UpperCAmelCase   ):




										"""simple docstring"""




										return EncodecFeatureExtractor.from_pretrained(self.checkpoint  ,   **__SCREAMING_SNAKE_CASE   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										shutil.rmtree(self.tmpdirname   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Union[str, Any]				=   self.get_tokenizer()
										__magic_name__					:				Union[str, Any]				=   self.get_feature_extractor()

										__magic_name__					:				Dict				=   MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE  ,   feature_extractor=__SCREAMING_SNAKE_CASE   )

										processor.save_pretrained(self.tmpdirname   )
										__magic_name__					:				Tuple				=   MusicgenProcessor.from_pretrained(self.tmpdirname   )

										self.assertEqual(processor.tokenizer.get_vocab()  ,   tokenizer.get_vocab()   )
										self.assertIsInstance(processor.tokenizer  ,   __SCREAMING_SNAKE_CASE   )

										self.assertEqual(processor.feature_extractor.to_json_string()  ,   feature_extractor.to_json_string()   )
										self.assertIsInstance(processor.feature_extractor  ,   __SCREAMING_SNAKE_CASE   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				int				=   MusicgenProcessor(tokenizer=self.get_tokenizer()  ,   feature_extractor=self.get_feature_extractor()   )
										processor.save_pretrained(self.tmpdirname   )

										__magic_name__					:				Optional[int]				=   self.get_tokenizer(bos_token='(BOS)'  ,   eos_token='(EOS)'   )
										__magic_name__					:				Dict				=   self.get_feature_extractor(do_normalize=__SCREAMING_SNAKE_CASE  ,   padding_value=1.0   )

										__magic_name__					:				Optional[int]				=   MusicgenProcessor.from_pretrained(
										    self.tmpdirname  ,   bos_token='(BOS)'  ,   eos_token='(EOS)'  ,   do_normalize=__SCREAMING_SNAKE_CASE  ,   padding_value=1.0   )

										self.assertEqual(processor.tokenizer.get_vocab()  ,   tokenizer_add_kwargs.get_vocab()   )
										self.assertIsInstance(processor.tokenizer  ,   __SCREAMING_SNAKE_CASE   )

										self.assertEqual(processor.feature_extractor.to_json_string()  ,   feature_extractor_add_kwargs.to_json_string()   )
										self.assertIsInstance(processor.feature_extractor  ,   __SCREAMING_SNAKE_CASE   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				List[Any]				=   self.get_feature_extractor()
										__magic_name__					:				int				=   self.get_tokenizer()

										__magic_name__					:				Union[str, Any]				=   MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE  ,   feature_extractor=__SCREAMING_SNAKE_CASE   )

										__magic_name__					:				List[Any]				=   floats_list((3, 1000)   )

										__magic_name__					:				str				=   feature_extractor(__SCREAMING_SNAKE_CASE  ,   return_tensors='np'   )
										__magic_name__					:				List[str]				=   processor(__SCREAMING_SNAKE_CASE  ,   return_tensors='np'   )

										for key in input_feat_extract.keys():
																self.assertAlmostEqual(input_feat_extract[key].sum()  ,   input_processor[key].sum()  ,   delta=1E-2   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Union[str, Any]				=   self.get_feature_extractor()
										__magic_name__					:				Optional[Any]				=   self.get_tokenizer()

										__magic_name__					:				str				=   MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE  ,   feature_extractor=__SCREAMING_SNAKE_CASE   )

										__magic_name__					:				List[str]				=   'This is a test string'

										__magic_name__					:				Tuple				=   processor(text=__SCREAMING_SNAKE_CASE   )

										__magic_name__					:				Any				=   tokenizer(__SCREAMING_SNAKE_CASE   )

										for key in encoded_tok.keys():
																self.assertListEqual(encoded_tok[key]  ,   encoded_processor[key]   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Tuple				=   self.get_feature_extractor()
										__magic_name__					:				List[str]				=   self.get_tokenizer()

										__magic_name__					:				List[Any]				=   MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE  ,   feature_extractor=__SCREAMING_SNAKE_CASE   )

										__magic_name__					:				Tuple				=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										__magic_name__					:				List[Any]				=   processor.batch_decode(sequences=__SCREAMING_SNAKE_CASE   )
										__magic_name__					:				Optional[int]				=   tokenizer.batch_decode(__SCREAMING_SNAKE_CASE   )

										self.assertListEqual(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				int				=   self.get_feature_extractor()
										__magic_name__					:				Optional[Any]				=   self.get_tokenizer()

										__magic_name__					:				str				=   MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE  ,   feature_extractor=__SCREAMING_SNAKE_CASE   )

										self.assertListEqual(
										    processor.model_input_names  ,   feature_extractor.model_input_names  ,   msg='`processor` and `feature_extractor` model input names do not match'  ,   )





				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Union[str, Any]				=   self.get_feature_extractor(padding_side='left'   )
										__magic_name__					:				Any				=   self.get_tokenizer()

										__magic_name__					:				Tuple				=   MusicgenProcessor(tokenizer=__SCREAMING_SNAKE_CASE  ,   feature_extractor=__SCREAMING_SNAKE_CASE   )

										__magic_name__					:				Dict				=   [floats_list((1, x)   )[0] for x in range(5  ,   20  ,   5   )]
										__magic_name__					:				Any				=   processor(__SCREAMING_SNAKE_CASE   ).padding_mask

										__magic_name__					:				Optional[Any]				=   np.asarray(floats_list((3, 20)   )   )[:, None, :]
										__magic_name__					:				Any				=   processor.batch_decode(__SCREAMING_SNAKE_CASE  ,   padding_mask=__SCREAMING_SNAKE_CASE   )

										self.assertIsInstance(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )

										for audio in decoded_audios:
																self.assertIsInstance(__SCREAMING_SNAKE_CASE  ,   np.ndarray   )

										self.assertTrue(decoded_audios[0].shape == (1, 10)   )
										self.assertTrue(decoded_audios[1].shape == (1, 15)   )
										self.assertTrue(decoded_audios[2].shape == (1, 20)   )




'''simple docstring'''

def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	int   ,     snake_case_				:	list[tuple[int, int, int]]							)       ->	list[tuple[int, int, int]]:
 SCREAMING_SNAKE_CASE  :  List[Any]								=		sorted(snake_case_   ,     key=lambda snake_case_							: edge[2]							)

 SCREAMING_SNAKE_CASE  :  str								=		list(range(snake_case_							)							)

 def find_parent(snake_case_				:	Union[str, Any]							):
  if i != parent[i]:
   SCREAMING_SNAKE_CASE  :  int								=		find_parent(parent[i]							)
  return parent[i]

 SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		0
 SCREAMING_SNAKE_CASE  :  Any								=		[]

 for edge in edges:
  SCREAMING_SNAKE_CASE  :  Dict								=		find_parent(edge[0]							)
  SCREAMING_SNAKE_CASE  :  Optional[int]								=		find_parent(edge[1]							)
  if parent_a != parent_b:
   minimum_spanning_tree_cost += edge[2]
   minimum_spanning_tree.append(snake_case_							)
   SCREAMING_SNAKE_CASE  :  Tuple								=		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)


