


'''simple docstring'''






import sys
from collections import defaultdict




class 	a       :
	def __init__(	self  )   ->							int:
						_a      =							[]
	def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							List[str]:
						return self.node_position[vertex]
	def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__  )   ->							Optional[Any]:
						_a      =							pos
	def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							Dict:


						if start > size // 2 - 1:
											return
						else:
											if 2 * start + 2 >= size:
																_a      =							2 * start + 1
											else:
																if heap[2 * start + 1] < heap[2 * start + 2]:
																					_a      =							2 * start + 1
																else:
																					_a      =							2 * start + 2
											if heap[smallest_child] < heap[start]:
																_a      =							heap[smallest_child], positions[smallest_child]
																_a      =							(
																    heap[start],
																    positions[start],
																)
																_a      =							temp, tempa

																_a      =							self.get_position(positions[smallest_child]  )
																self.set_position(
																    positions[smallest_child] ,			self.get_position(positions[start]  )  )
																self.set_position(positions[start] ,			UpperCamelCase__  )

																self.top_to_bottom(UpperCamelCase__ ,			UpperCamelCase__ ,			UpperCamelCase__ ,			UpperCamelCase__  )
	def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__  )   ->							List[Any]:
						_a      =							position[index]

						while index != 0:
											_a      =							int((index - 2) / 2  ) if index % 2 == 0 else int((index - 1) / 2  )

											if val < heap[parent]:
																_a      =							heap[parent]
																_a      =							position[parent]
																self.set_position(position[parent] ,			UpperCamelCase__  )
											else:
																_a      =							val
																_a      =							temp
																self.set_position(UpperCamelCase__ ,			UpperCamelCase__  )
																break
											_a      =							parent
						else:
											_a      =							val
											_a      =							temp
											self.set_position(UpperCamelCase__ ,			0  )
	def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__  )   ->							int:
						_a      =							len(UpperCamelCase__  ) // 2 - 1
						for i in range(UpperCamelCase__ ,			-1 ,			-1  ):
											self.top_to_bottom(UpperCamelCase__ ,			UpperCamelCase__ ,			len(UpperCamelCase__  ) ,			UpperCamelCase__  )




	def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__  )   ->							List[str]:
						_a      =							positions[0]
						_a      =							sys.maxsize
						self.top_to_bottom(UpperCamelCase__ ,			0 ,			len(UpperCamelCase__  ) ,			UpperCamelCase__  )
						return temp






def 		_A			(lowerCAmelCase__					:Tuple						)				->					str:




					'''simple docstring'''



					_a      =							Heap()

					_a      =							[0] * len(__SCREAMING_SNAKE_CASE						)
					_a      =							[-1] * len(__SCREAMING_SNAKE_CASE						)  # Neighboring Tree Vertex of selected vertex
					# Minimum Distance of explored vertex with neighboring vertex of partial tree
					# formed in graph
					_a      =							[]  # Heap of Distance of vertices from their neighboring vertex
					_a      =							[]

					for vertex in range(len(__SCREAMING_SNAKE_CASE						)						):
										distance_tv.append(sys.maxsize						)
										positions.append(__SCREAMING_SNAKE_CASE						)
										heap.node_position.append(__SCREAMING_SNAKE_CASE						)

					_a      =							[]
					_a      =							1
					_a      =							sys.maxsize
					for neighbor, distance in adjacency_list[0]:
										_a      =							0
										_a      =							distance
					heap.heapify(__SCREAMING_SNAKE_CASE			,  __SCREAMING_SNAKE_CASE						)

					for _ in range(1			,  len(__SCREAMING_SNAKE_CASE						)						):
										_a      =							heap.delete_minimum(__SCREAMING_SNAKE_CASE			,  __SCREAMING_SNAKE_CASE						)
										if visited[vertex] == 0:
															tree_edges.append((nbr_tv[vertex], vertex)						)
															_a      =							1
															for neighbor, distance in adjacency_list[vertex]:
																				if (
																				    visited[neighbor] == 0
																				    and distance < distance_tv[heap.get_position(__SCREAMING_SNAKE_CASE						)]
																				):
																									_a      =							distance
																									heap.bottom_to_top(
																									    __SCREAMING_SNAKE_CASE			,  heap.get_position(__SCREAMING_SNAKE_CASE						)			,  __SCREAMING_SNAKE_CASE			,  __SCREAMING_SNAKE_CASE						)
																									_a      =							vertex
					return tree_edges


if __name__ == "__main__":  # pragma: no cover
	# < --------- Prims Algorithm --------- >
	a_   :      Any				    =      int(input("Enter number of edges: ").strip())
	a_   :      Optional[Any]				    =      defaultdict(list)
	for _ in range(edges_number):
		a_   :      Any				    =      [int(x) for x in input().strip().split()]
		adjacency_list[edge[0]].append([edge[1], edge[2]])
		adjacency_list[edge[1]].append([edge[0], edge[2]])
	print(prisms_algorithm(adjacency_list))





'''simple docstring'''






import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


a_   :      Union[str, Any]				    =      logging.get_logger(__name__)

a_   :      Union[str, Any]				    =      {"vocab_file": "spiece.model"}

a_   :      List[Any]				    =      {
    "vocab_file": {
        "bert_for_seq_generation": (
            "https://huggingface.co/google/bert_for_seq_generation_L-24_bbc_encoder/resolve/main/spiece.model"
        ),
    }
}

a_   :      Dict				    =      {"bert_for_seq_generation": 5_1_2}




class 	a       (       _SCREAMING_SNAKE_CASE    ):
 _lowerCAmelCase	   =		VOCAB_FILES_NAMES
 _lowerCAmelCase	   =		PRETRAINED_VOCAB_FILES_MAP
 _lowerCAmelCase	   =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 _lowerCAmelCase	   =		[]
 _lowerCAmelCase	   =		["""input_ids""", """attention_mask"""]
 def __init__(	self ,			__magic_name__ ,			__magic_name__="<s>" ,			__magic_name__="</s>" ,			__magic_name__="<unk>" ,			__magic_name__="<pad>" ,			__magic_name__="<::::>" ,			__magic_name__ = None ,			**__magic_name__ ,			)   ->							None:
      _a      =							{} if sp_model_kwargs is None else sp_model_kwargs

      # Add extra_ids to the special token list
      super().__init__(
          bos_token=__magic_name__ ,			eos_token=__magic_name__ ,			unk_token=__magic_name__ ,			pad_token=__magic_name__ ,			sep_token=__magic_name__ ,			sp_model_kwargs=self.sp_model_kwargs ,			**__magic_name__ ,			)

      _a      =							vocab_file

      _a      =							spm.SentencePieceProcessor(**self.sp_model_kwargs  )
      self.sp_model.Load(__magic_name__  )
 @property
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      return self.sp_model.get_piece_size()
 def 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							{self.convert_ids_to_tokens(__magic_name__  ): i for i in range(self.vocab_size  )}
      vocab.update(self.added_tokens_encoder  )
      return vocab
 def __getstate__(	self  )   ->							Any:
      _a      =							self.__dict__.copy()
      _a      =							None
      return state
 def __setstate__(	self ,			__magic_name__  )   ->							int:
      _a      =							d

      # for backward compatibility
      if not hasattr(self ,			'sp_model_kwargs'  ):
           _a      =							{}

      _a      =							spm.SentencePieceProcessor(**self.sp_model_kwargs  )
      self.sp_model.Load(self.vocab_file  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							List[str]:
      return self.sp_model.encode(__magic_name__ ,			out_type=__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							List[str]:
      return self.sp_model.piece_to_id(__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							List[str]:
      _a      =							self.sp_model.IdToPiece(__magic_name__  )
      return token
 def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							Optional[Any]:
      _a      =							[]
      _a      =							''
      for token in tokens:
           # make sure that special tokens are not decoded using sentencepiece model
           if token in self.all_special_tokens:
                out_string += self.sp_model.decode(__magic_name__  ) + token
                _a      =							[]
           else:
                current_sub_tokens.append(__magic_name__  )
      out_string += self.sp_model.decode(__magic_name__  )
      return out_string.strip()




 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ = None  )   ->							Tuple[str]:
      if not os.path.isdir(__magic_name__  ):
           logger.error(f'Vocabulary path ({save_directory}) should be a directory'  )
           return
      _a      =							os.path.join(
          __magic_name__ ,			(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']  )

      if os.path.abspath(self.vocab_file  ) != os.path.abspath(__magic_name__  ) and os.path.isfile(self.vocab_file  ):
           copyfile(self.vocab_file ,			__magic_name__  )
      elif not os.path.isfile(self.vocab_file  ):
           with open(__magic_name__ ,			'wb'  ) as fi:
                _a      =							self.sp_model.serialized_model_proto()
                fi.write(__magic_name__  )

      return (out_vocab_file,)

