





'''simple docstring'''






from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
      import tensorflow as tf

      from transformers import TFBlipTextModel
      from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST




class  UpperCAmelCase     :




      def __init__(			self			: List[str]			,			__snake_case			: str			,			__snake_case			: Dict=12			,			__snake_case			: Dict=7			,			__snake_case			: str=True			,			__snake_case			: List[Any]=True			,			__snake_case			: Dict=True			,			__snake_case			: Optional[int]=99			,			__snake_case			: Dict=32			,			__snake_case			: Optional[Any]=32			,			__snake_case			: Union[str, Any]=2			,			__snake_case			: List[str]=4			,			__snake_case			: Optional[int]=37			,			__snake_case			: Union[str, Any]=0.1			,			__snake_case			: Optional[int]=0.1			,			__snake_case			: int=5_12			,			__snake_case			: List[Any]=0.02			,			__snake_case			: Any=0			,			__snake_case			: List[Any]=None			,			)				->      int:
            _lowerCAmelCase							     =							parent
            _lowerCAmelCase							     =							batch_size
            _lowerCAmelCase							     =							seq_length
            _lowerCAmelCase							     =							is_training
            _lowerCAmelCase							     =							use_input_mask
            _lowerCAmelCase							     =							use_labels
            _lowerCAmelCase							     =							vocab_size
            _lowerCAmelCase							     =							hidden_size
            _lowerCAmelCase							     =							projection_dim
            _lowerCAmelCase							     =							num_hidden_layers
            _lowerCAmelCase							     =							num_attention_heads
            _lowerCAmelCase							     =							intermediate_size
            _lowerCAmelCase							     =							dropout
            _lowerCAmelCase							     =							attention_dropout
            _lowerCAmelCase							     =							max_position_embeddings
            _lowerCAmelCase							     =							initializer_range
            _lowerCAmelCase							     =							scope
            _lowerCAmelCase							     =							bos_token_id




      def 				lowercase__    (			self			: List[Any]  )				->      List[str]:
            _lowerCAmelCase							     =							ids_tensor([self.batch_size, self.seq_length]			,			self.vocab_size  )

            _lowerCAmelCase							     =							None
            if self.use_input_mask:
                  _lowerCAmelCase							     =							random_attention_mask([self.batch_size, self.seq_length]  )

            if input_mask is not None:
                  _lowerCAmelCase							     =							input_mask.numpy()
                  _lowerCAmelCase     ,							_lowerCAmelCase							     =							input_mask.shape
                  _lowerCAmelCase							     =							np.random.randint(1			,			seq_length - 1			,			size=(batch_size,)  )
                  for batch_idx, start_index in enumerate(__snake_case  ):
                        _lowerCAmelCase							     =							1
                        _lowerCAmelCase							     =							0

            _lowerCAmelCase							     =							self.get_config()

            return config, input_ids, tf.convert_to_tensor(__snake_case  )




      def 				lowercase__    (			self			: List[str]  )				->      Optional[int]:
            return BlipTextConfig(
                vocab_size=self.vocab_size			,			hidden_size=self.hidden_size			,			projection_dim=self.projection_dim			,			num_hidden_layers=self.num_hidden_layers			,			num_attention_heads=self.num_attention_heads			,			intermediate_size=self.intermediate_size			,			dropout=self.dropout			,			attention_dropout=self.attention_dropout			,			max_position_embeddings=self.max_position_embeddings			,			initializer_range=self.initializer_range			,			bos_token_id=self.bos_token_id			,			)




      def 				lowercase__    (			self			: int			,			__snake_case			: Any			,			__snake_case			: List[str]			,			__snake_case			: List[Any]  )				->      Optional[int]:
            _lowerCAmelCase							     =							TFBlipTextModel(config=__snake_case  )
            _lowerCAmelCase							     =							model(__snake_case			,			attention_mask=__snake_case			,			training=__snake_case  )
            _lowerCAmelCase							     =							model(__snake_case			,			training=__snake_case  )
            self.parent.assertEqual(result.last_hidden_state.shape			,			(self.batch_size, self.seq_length, self.hidden_size)  )
            self.parent.assertEqual(result.pooler_output.shape			,			(self.batch_size, self.hidden_size)  )




      def 				lowercase__    (			self			: Optional[int]  )				->      Any:
            _lowerCAmelCase							     =							self.prepare_config_and_inputs()
            _lowerCAmelCase     ,							_lowerCAmelCase     ,							_lowerCAmelCase							     =							config_and_inputs
            _lowerCAmelCase							     =							{"""input_ids""": input_ids, """attention_mask""": input_mask}
            return config, inputs_dict




@require_tf
class  UpperCAmelCase     (			snake_case_							,		unittest.TestCase   ):
      _lowercase:			str						     =   (TFBlipTextModel,) if is_tf_available() else ()
      _lowercase:			Dict						     =   False
      _lowercase:			Dict						     =   False
      _lowercase:			Dict						     =   False




      def 				lowercase__    (			self			: List[Any]  )				->      Optional[int]:
            _lowerCAmelCase							     =							BlipTextModelTester(self  )
            _lowerCAmelCase							     =							ConfigTester(self			,			config_class=__snake_case			,			hidden_size=37  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      Optional[Any]:
            self.config_tester.run_common_tests()




      def 				lowercase__    (			self			: int  )				->      List[str]:
            _lowerCAmelCase							     =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__snake_case  )




      def 				lowercase__    (			self			: str  )				->      Union[str, Any]:
            pass




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




      @unittest.skip(reason="""Blip does not use inputs_embeds"""  )
      def 				lowercase__    (			self			: List[Any]  )				->      List[Any]:
            pass




      @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""  )
      def 				lowercase__    (			self			: List[Any]  )				->      List[str]:
            pass




      @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""  )
      def 				lowercase__    (			self			: List[str]  )				->      int:
            pass




      @slow
      def 				lowercase__    (			self			: List[str]  )				->      List[str]:
            for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  _lowerCAmelCase							     =							TFBlipTextModel.from_pretrained(__snake_case  )
                  self.assertIsNotNone(__snake_case  )




      def 				lowercase__    (			self			: List[str]			,			__snake_case			: List[str]=True  )				->      Any:
            super().test_pt_tf_model_equivalence(allow_missing_keys=__snake_case  )










"""simple docstring"""


import sys
from collections import defaultdict
class   _UpperCamelCase  :
							'''simple docstring'''







							def __init__(     self	):
										__lowerCAmelCase				    =			[]

							def 			snake_case				(     self    ,   __a	):
										return self.node_position[vertex]

							def 			snake_case				(     self    ,   __a    ,   __a	):
										__lowerCAmelCase				    =			pos

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

																__lowerCAmelCase				    =			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 			snake_case				(     self    ,   __a    ,   __a    ,   __a    ,   __a	):
										__lowerCAmelCase				    =			position[index]

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

													if val < heap[parent]:
																__lowerCAmelCase				    =			heap[parent]
																__lowerCAmelCase				    =			position[parent]
																self.set_position(position[parent]    ,   __a	)
													else:
																__lowerCAmelCase				    =			val
																__lowerCAmelCase				    =			temp
																self.set_position(__a    ,   __a	)
																break
													__lowerCAmelCase				    =			parent
										else:
													__lowerCAmelCase				    =			val
													__lowerCAmelCase				    =			temp
													self.set_position(__a    ,   0	)

							def 			snake_case				(     self    ,   __a    ,   __a	):
										__lowerCAmelCase				    =			len(__a	) // 2 - 1
										for i in range(__a    ,   -1    ,   -1	):
													self.top_to_bottom(__a    ,   __a    ,   len(__a	)    ,   __a	)



							def 			snake_case				(     self    ,   __a    ,   __a	):
										__lowerCAmelCase				    =			positions[0]
										__lowerCAmelCase				    =			sys.maxsize
										self.top_to_bottom(__a    ,   0    ,   len(__a	)    ,   __a	)
										return temp


def _lowerCamelCase	(		_UpperCamelCase      ):

			'''simple docstring'''




			__lowerCAmelCase				    =			Heap()

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

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

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

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


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




