
"""simple docstring"""




from collections import deque

def __snake_case (      UpperCamelCase    )       ->    Dict:


		"""simple docstring"""





		return input(UpperCamelCase    ).strip().split(''' '''    )

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    dict[int, list[int]]:


		"""simple docstring"""





		a__   		=     {}
		for i in range(UpperCamelCase    ):
				a__   		=     []

		for e in range(UpperCamelCase    ):
				a__		,	a__   		=     (int(UpperCamelCase    ) for i in _input(f"Edge {e + 1}: <node1> <node2> "    ))
				graph[x].append(UpperCamelCase    )
		return graph

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    dict[int, list[int]]:


		"""simple docstring"""





		a__   		=     {}
		for i in range(UpperCamelCase    ):
				a__   		=     []

		for e in range(UpperCamelCase    ):
				a__		,	a__   		=     (int(UpperCamelCase    ) for i in _input(f"Edge {e + 1}: <node1> <node2> "    ))
				graph[x].append(UpperCamelCase    )
				graph[y].append(UpperCamelCase    )
		return graph

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    dict[int, list[tuple[int, int]]]:


		"""simple docstring"""





		a__   		=     {}
		for i in range(UpperCamelCase    ):
				a__   		=     []

		for e in range(UpperCamelCase    ):
				a__		,	a__		,	a__   		=     (int(UpperCamelCase    ) for i in _input(f"Edge {e + 1}: <node1> <node2> <weight> "    ))
				graph[x].append((y, w)    )
				graph[y].append((x, w)    )
		return graph


if __name__ == "__main__":
					__lowerCAmelCase				,__lowerCAmelCase							:  Optional[Any] 				=		(int(i) for i in _input('''Number of nodes and edges: '''))

					__lowerCAmelCase							:  Optional[int] 				=		int(
					    _input(
					        '''Press 1 or 2 or 3 \n'''
					        '''1. Unweighted directed \n'''
					        '''2. Unweighted undirected \n'''
					        '''3. Weighted undirected \n'''
					    )[0]
					)

					__lowerCAmelCase							:  int 				=		{
					    1: initialize_unweighted_directed_graph,
					    2: initialize_unweighted_undirected_graph,
					    3: initialize_weighted_undirected_graph,
					}[graph_choice](n, m)

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    Dict:


		"""simple docstring"""





		a__		,	a__   		=     {s}, [s]
		print(UpperCamelCase    )
		while _s:
				a__   		=     0
				for i in g[_s[-1]]:
						if i not in vis:
								_s.append(UpperCamelCase    )
								vis.add(UpperCamelCase    )
								a__   		=     1
								print(UpperCamelCase    )
								break
				if not flag:
						_s.pop()

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    int:


		"""simple docstring"""





		a__		,	a__   		=     {s}, deque([s]    )
		print(UpperCamelCase    )
		while q:
				a__   		=     q.popleft()
				for v in g[u]:
						if v not in vis:
								vis.add(UpperCamelCase    )
								q.append(UpperCamelCase    )
								print(UpperCamelCase    )

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    Any:


		"""simple docstring"""





		a__		,	a__		,	a__   		=     {s: 0}, set(), {s: 0}
		while True:
				if len(UpperCamelCase    ) == len(UpperCamelCase    ) - 1:
						break
				a__   		=     100_000
				for i in dist:
						if i not in known and dist[i] < mini:
								a__   		=     dist[i]
								a__   		=     i
				known.add(UpperCamelCase    )
				for v in g[u]:
						if v[0] not in known and dist[u] + v[1] < dist.get(v[0]						,					100_000    ):
								a__   		=     dist[u] + v[1]
								a__   		=     u
		for i in dist:
				if i != s:
						print(dist[i]    )

def __snake_case (      UpperCamelCase						,					UpperCamelCase=None						,					UpperCamelCase=None    )       ->    List[Any]:


		"""simple docstring"""





		if q is None:
				a__   		=     [1]
		if ind is None:
				a__   		=     [0] * (len(UpperCamelCase    ) + 1)  # SInce oth Index is ignored
				for u in g:
						for v in g[u]:
								ind[v] += 1
				a__   		=     deque()
				for i in g:
						if ind[i] == 0:
								q.append(UpperCamelCase    )
		if len(UpperCamelCase    ) == 0:
				return
		a__   		=     q.popleft()
		print(UpperCamelCase    )
		for w in g[v]:
				ind[w] -= 1
				if ind[w] == 0:
						q.append(UpperCamelCase    )
		topo(UpperCamelCase						,					UpperCamelCase						,					UpperCamelCase    )

def __snake_case (      )       ->    List[Any]:


		"""simple docstring"""





		a__   		=     input().strip()
		a__   		=     []
		for _ in range(UpperCamelCase    ):
				a.append(map(UpperCamelCase						,					input().strip().split()    )    )
		return a, n

def __snake_case (      UpperCamelCase    )       ->    Any:


		"""simple docstring"""





		((a__)		,	(a__))   		=     a_and_n
		a__   		=     list(UpperCamelCase    )
		a__   		=     [[0] * n for i in range(UpperCamelCase    )]
		for k in range(UpperCamelCase    ):
				for i in range(UpperCamelCase    ):
						for j in range(UpperCamelCase    ):
								if dist[i][j] > dist[i][k] + dist[k][j]:
										a__   		=     dist[i][k] + dist[k][j]
										a__   		=     k
		print(UpperCamelCase    )

def __snake_case (      UpperCamelCase						,					UpperCamelCase    )       ->    Dict:


		"""simple docstring"""





		a__		,	a__		,	a__   		=     {s: 0}, set(), {s: 0}
		while True:
				if len(UpperCamelCase    ) == len(UpperCamelCase    ) - 1:
						break
				a__   		=     100_000
				for i in dist:
						if i not in known and dist[i] < mini:
								a__   		=     dist[i]
								a__   		=     i
				known.add(UpperCamelCase    )
				for v in g[u]:
						if v[0] not in known and v[1] < dist.get(v[0]						,					100_000    ):
								a__   		=     v[1]
								a__   		=     u
		return dist

def __snake_case (      )       ->    int:


		"""simple docstring"""





		a__		,	a__   		=     map(UpperCamelCase						,					input().split(''' '''    )    )
		a__   		=     []
		for _ in range(UpperCamelCase    ):
				edges.append(map(UpperCamelCase						,					input().split(''' '''    )    )    )
		return edges, n

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


		"""simple docstring"""





		((a__)		,	(a__))   		=     e_and_n
		e.sort(reverse=UpperCamelCase						,					key=lambda UpperCamelCase    : x[2]    )
		a__   		=     [{i} for i in range(1						,					n + 1    )]
		while True:
				if len(UpperCamelCase    ) == 1:
						break
				print(UpperCamelCase    )
				a__   		=     e.pop()
				for i in range(len(UpperCamelCase    )    ):
						if x[0] in s[i]:
								break
				for j in range(len(UpperCamelCase    )    ):
						if x[1] in s[j]:
								if i == j:
										break
								s[j].update(s[i]    )
								s.pop(UpperCamelCase    )
								break




def __snake_case (      UpperCamelCase    )       ->    List[Any]:


		"""simple docstring"""





		a__   		=     []
		for node in graph:
				if not graph[node]:
						isolated.append(UpperCamelCase    )
		return isolated






"""simple docstring"""




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


__lowerCAmelCase							:  Union[str, Any] 				=		random.Random()

def __snake_case (      UpperCamelCase						,					UpperCamelCase=1.0						,					UpperCamelCase=None						,					UpperCamelCase=None    )       ->    Tuple:


		"""simple docstring"""





		if rng is None:
				a__   		=     global_rng

		a__   		=     []
		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 SCREAMING_SNAKE_CASE       (      unittest.TestCase					):






	'''simple docstring'''







	def    _UpperCamelCase							(  self :Optional[int]			)			->   List[str]:

			'''simple docstring'''






			a__   		=     '''facebook/musicgen-small'''
			a__   		=     tempfile.mkdtemp()


	def    _UpperCamelCase							(  self :Union[str, Any]       ,    **__magic_name__ :Union[str, Any]			)			->   str:

			'''simple docstring'''






			return TaTokenizer.from_pretrained(self.checkpoint       ,    **__magic_name__			)


	def    _UpperCamelCase							(  self :Optional[int]       ,    **__magic_name__ :Any			)			->   Optional[int]:

			'''simple docstring'''






			return EncodecFeatureExtractor.from_pretrained(self.checkpoint       ,    **__magic_name__			)


	def    _UpperCamelCase							(  self :Optional[int]			)			->   Optional[int]:

			'''simple docstring'''






			shutil.rmtree(self.tmpdirname			)


	def    _UpperCamelCase							(  self :Tuple			)			->   Any:

			'''simple docstring'''






			a__   		=     self.get_tokenizer()
			a__   		=     self.get_feature_extractor()

			a__   		=     MusicgenProcessor(tokenizer=__magic_name__       ,    feature_extractor=__magic_name__			)

			processor.save_pretrained(self.tmpdirname			)
			a__   		=     MusicgenProcessor.from_pretrained(self.tmpdirname			)

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

			self.assertEqual(processor.feature_extractor.to_json_string()       ,    feature_extractor.to_json_string()			)
			self.assertIsInstance(processor.feature_extractor       ,    __magic_name__			)


	def    _UpperCamelCase							(  self :Dict			)			->   Optional[int]:

			'''simple docstring'''






			a__   		=     MusicgenProcessor(tokenizer=self.get_tokenizer()       ,    feature_extractor=self.get_feature_extractor()			)
			processor.save_pretrained(self.tmpdirname			)

			a__   		=     self.get_tokenizer(bos_token='''(BOS)'''       ,    eos_token='''(EOS)'''			)
			a__   		=     self.get_feature_extractor(do_normalize=__magic_name__       ,    padding_value=1.0			)

			a__   		=     MusicgenProcessor.from_pretrained(
			    self.tmpdirname       ,    bos_token='''(BOS)'''       ,    eos_token='''(EOS)'''       ,    do_normalize=__magic_name__       ,    padding_value=1.0			)

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

			self.assertEqual(processor.feature_extractor.to_json_string()       ,    feature_extractor_add_kwargs.to_json_string()			)
			self.assertIsInstance(processor.feature_extractor       ,    __magic_name__			)


	def    _UpperCamelCase							(  self :Any			)			->   Tuple:

			'''simple docstring'''






			a__   		=     self.get_feature_extractor()
			a__   		=     self.get_tokenizer()

			a__   		=     MusicgenProcessor(tokenizer=__magic_name__       ,    feature_extractor=__magic_name__			)

			a__   		=     floats_list((3, 1000)			)

			a__   		=     feature_extractor(__magic_name__       ,    return_tensors='''np'''			)
			a__   		=     processor(__magic_name__       ,    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 :Tuple			)			->   Dict:

			'''simple docstring'''






			a__   		=     self.get_feature_extractor()
			a__   		=     self.get_tokenizer()

			a__   		=     MusicgenProcessor(tokenizer=__magic_name__       ,    feature_extractor=__magic_name__			)

			a__   		=     '''This is a test string'''

			a__   		=     processor(text=__magic_name__			)

			a__   		=     tokenizer(__magic_name__			)

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


	def    _UpperCamelCase							(  self :Tuple			)			->   Optional[Any]:

			'''simple docstring'''






			a__   		=     self.get_feature_extractor()
			a__   		=     self.get_tokenizer()

			a__   		=     MusicgenProcessor(tokenizer=__magic_name__       ,    feature_extractor=__magic_name__			)

			a__   		=     [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

			a__   		=     processor.batch_decode(sequences=__magic_name__			)
			a__   		=     tokenizer.batch_decode(__magic_name__			)

			self.assertListEqual(__magic_name__       ,    __magic_name__			)


	def    _UpperCamelCase							(  self :Optional[Any]			)			->   int:

			'''simple docstring'''






			a__   		=     self.get_feature_extractor()
			a__   		=     self.get_tokenizer()

			a__   		=     MusicgenProcessor(tokenizer=__magic_name__       ,    feature_extractor=__magic_name__			)

			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 :Any			)			->   List[str]:

			'''simple docstring'''






			a__   		=     self.get_feature_extractor(padding_side='''left'''			)
			a__   		=     self.get_tokenizer()

			a__   		=     MusicgenProcessor(tokenizer=__magic_name__       ,    feature_extractor=__magic_name__			)

			a__   		=     [floats_list((1, x)			)[0] for x in range(5       ,    20       ,    5			)]
			a__   		=     processor(__magic_name__			).padding_mask

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

			self.assertIsInstance(__magic_name__       ,    __magic_name__			)

			for audio in decoded_audios:
					self.assertIsInstance(__magic_name__       ,    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)			)




