
import sys
from collections import defaultdict





class       _snake_case					:







			def __init__(				self		):
				__magic_name__		:		Union[str, Any]	   =     []







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				return self.node_position[vertex]







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				__magic_name__		:		str	   =     pos







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a						,   _a						,   _a		):
				if start > size // 2 - 1:
					return
				else:
					if 2 * start + 2 >= size:
						__magic_name__		:		Any	   =     2 * start + 1
					else:
						if heap[2 * start + 1] < heap[2 * start + 2]:
							__magic_name__		:		Optional[Any]	   =     2 * start + 1
						else:
							__magic_name__		:		Dict	   =     2 * start + 2
					if heap[smallest_child] < heap[start]:
						__magic_name__   ,    __magic_name__		:		Any	   =     heap[smallest_child], positions[smallest_child]
						__magic_name__   ,    __magic_name__		:		Dict	   =     (
						    heap[start],
						    positions[start],
						)
						__magic_name__   ,    __magic_name__		:		Union[str, Any]	   =     temp, tempa

						__magic_name__		:		Optional[Any]	   =     self.get_position(positions[smallest_child]		)
						self.set_position(
						    positions[smallest_child]						,   self.get_position(positions[start]		)		)
						self.set_position(positions[start]						,   _a		)

						self.top_to_bottom(_a						,   _a						,   _a						,   _a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a						,   _a						,   _a		):
				__magic_name__		:		int	   =     position[index]

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

					if val < heap[parent]:
						__magic_name__		:		Optional[int]	   =     heap[parent]
						__magic_name__		:		List[str]	   =     position[parent]
						self.set_position(position[parent]						,   _a		)
					else:
						__magic_name__		:		Dict	   =     val
						__magic_name__		:		Optional[Any]	   =     temp
						self.set_position(_a						,   _a		)
						break
					__magic_name__		:		List[Any]	   =     parent
				else:
					__magic_name__		:		Union[str, Any]	   =     val
					__magic_name__		:		Optional[int]	   =     temp
					self.set_position(_a						,   0		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				__magic_name__		:		Tuple	   =     len(_a		) // 2 - 1
				for i in range(_a						,   -1						,   -1		):
					self.top_to_bottom(_a						,   _a						,   len(_a		)						,   _a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a		):
				__magic_name__		:		List[Any]	   =     positions[0]
				__magic_name__		:		List[str]	   =     sys.maxsize
				self.top_to_bottom(_a						,   0						,   len(_a		)						,   _a		)
				return temp







def   lowerCAmelCase_						(					_snake_case      :  Optional[Any]   )				->		Tuple:







	'''simple docstring'''


	__magic_name__		:		Union[str, Any]	   =     Heap()

	__magic_name__		:		str	   =     [0] * len(_snake_case   )
	__magic_name__		:		Optional[Any]	   =     [-1] * len(_snake_case   )  # Neighboring Tree Vertex of selected vertex
	# Minimum Distance of explored vertex with neighboring vertex of partial tree
	# formed in graph
	__magic_name__		:		Optional[Any]	   =     []  # Heap of Distance of vertices from their neighboring vertex
	__magic_name__		:		List[Any]	   =     []

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

	__magic_name__		:		Any	   =     []
	__magic_name__		:		int	   =     1
	__magic_name__		:		Tuple	   =     sys.maxsize
	for neighbor, distance in adjacency_list[0]:
		__magic_name__		:		List[str]	   =     0
		__magic_name__		:		Union[str, Any]	   =     distance
	heap.heapify(_snake_case      ,   _snake_case   )

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


if __name__ == "__main__":  # pragma: no cover
				# < --------- Prims Algorithm --------- >
				snake_case :		Any							      =  int(input("Enter number of edges: ").strip())
				snake_case :		List[Any]							      =  defaultdict(list)
				for _ in range(edges_number):
								snake_case :		List[str]							      =  [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))


from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)
