



'''simple docstring'''





import sys
from collections import defaultdict


class 				snake_case :



       def __init__(				self      )  ->							List[str]:
           lowercase__		       =						[]



       def 							_a      (				self     ,UpperCAmelCase_      )  ->							Union[str, Any]:
           return self.node_position[vertex]



       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							Dict:
           lowercase__		       =						pos



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

                   lowercase__		       =						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 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							Tuple:
           lowercase__		       =						position[index]

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

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



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







       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							Tuple:
           lowercase__		       =						positions[0]
           lowercase__		       =						sys.maxsize
           self.top_to_bottom(UpperCAmelCase_     ,0     ,len(UpperCAmelCase_      )     ,UpperCAmelCase_      )
           return temp





def        lowerCamelCase  (				_snake_case  :						Union[str, Any]       ):





    '''simple docstring'''


    lowercase__		       =						Heap()

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

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

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

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


if __name__ == "__main__":  # pragma: no cover
 # < --------- Prims Algorithm --------- >
 SCREAMING_SNAKE_CASE__      					=     int(input("Enter number of edges: ").strip())
 SCREAMING_SNAKE_CASE__      					=     defaultdict(list)
 for _ in range(edges_number):
  SCREAMING_SNAKE_CASE__      					=     [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 copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
 pass

from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__      					=     logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__      					=     {
    "kakaobrain/align-base": "https://huggingface.co/kakaobrain/align-base/resolve/main/config.json",
}


class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :Optional[int]						   =					"align_text_model"



       def __init__(				self     ,UpperCAmelCase_=30_522     ,UpperCAmelCase_=768     ,UpperCAmelCase_=12     ,UpperCAmelCase_=12     ,UpperCAmelCase_=3_072     ,UpperCAmelCase_="gelu"     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=512     ,UpperCAmelCase_=2     ,UpperCAmelCase_=0.02     ,UpperCAmelCase_=1E-1_2     ,UpperCAmelCase_=0     ,UpperCAmelCase_="absolute"     ,UpperCAmelCase_=True     ,**UpperCAmelCase_     ,)  ->							List[str]:
           super().__init__(**UpperCAmelCase_      )

           lowercase__		       =						vocab_size
           lowercase__		       =						hidden_size
           lowercase__		       =						num_hidden_layers
           lowercase__		       =						num_attention_heads
           lowercase__		       =						hidden_act
           lowercase__		       =						intermediate_size
           lowercase__		       =						hidden_dropout_prob
           lowercase__		       =						attention_probs_dropout_prob
           lowercase__		       =						max_position_embeddings
           lowercase__		       =						type_vocab_size
           lowercase__		       =						initializer_range
           lowercase__		       =						layer_norm_eps
           lowercase__		       =						position_embedding_type
           lowercase__		       =						use_cache
           lowercase__		       =						pad_token_id







       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							"PretrainedConfig":
           cls._set_token_in_kwargs(UpperCAmelCase_      )

           lowercase__       ,       lowercase__		       =						cls.get_config_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )

           # get the text config dict if we are loading from AlignConfig
           if config_dict.get("model_type"      ) == "align":
               lowercase__		       =						config_dict["text_config"]

           if "model_type" in config_dict and hasattr(cls     ,"model_type"      ) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                   F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''      )

           return cls.from_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )





class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :Tuple						   =					"align_vision_model"



       def __init__(				self     ,UpperCAmelCase_ = 3     ,UpperCAmelCase_ = 600     ,UpperCAmelCase_ = 2.0     ,UpperCAmelCase_ = 3.1     ,UpperCAmelCase_ = 8     ,UpperCAmelCase_ = [3, 3, 5, 3, 5, 5, 3]     ,UpperCAmelCase_ = [32, 16, 24, 40, 80, 112, 192]     ,UpperCAmelCase_ = [16, 24, 40, 80, 112, 192, 320]     ,UpperCAmelCase_ = []     ,UpperCAmelCase_ = [1, 2, 2, 2, 1, 2, 1]     ,UpperCAmelCase_ = [1, 2, 2, 3, 3, 4, 1]     ,UpperCAmelCase_ = [1, 6, 6, 6, 6, 6, 6]     ,UpperCAmelCase_ = 0.25     ,UpperCAmelCase_ = "swish"     ,UpperCAmelCase_ = 2_560     ,UpperCAmelCase_ = "mean"     ,UpperCAmelCase_ = 0.02     ,UpperCAmelCase_ = 0.0_01     ,UpperCAmelCase_ = 0.99     ,UpperCAmelCase_ = 0.2     ,**UpperCAmelCase_     ,)  ->							Union[str, Any]:
           super().__init__(**UpperCAmelCase_      )

           lowercase__		       =						num_channels
           lowercase__		       =						image_size
           lowercase__		       =						width_coefficient
           lowercase__		       =						depth_coefficient
           lowercase__		       =						depth_divisor
           lowercase__		       =						kernel_sizes
           lowercase__		       =						in_channels
           lowercase__		       =						out_channels
           lowercase__		       =						depthwise_padding
           lowercase__		       =						strides
           lowercase__		       =						num_block_repeats
           lowercase__		       =						expand_ratios
           lowercase__		       =						squeeze_expansion_ratio
           lowercase__		       =						hidden_act
           lowercase__		       =						hidden_dim
           lowercase__		       =						pooling_type
           lowercase__		       =						initializer_range
           lowercase__		       =						batch_norm_eps
           lowercase__		       =						batch_norm_momentum
           lowercase__		       =						drop_connect_rate
           lowercase__		       =						sum(UpperCAmelCase_      ) * 4







       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							"PretrainedConfig":
           cls._set_token_in_kwargs(UpperCAmelCase_      )

           lowercase__       ,       lowercase__		       =						cls.get_config_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )

           # get the vision config dict if we are loading from AlignConfig
           if config_dict.get("model_type"      ) == "align":
               lowercase__		       =						config_dict["vision_config"]

           if "model_type" in config_dict and hasattr(cls     ,"model_type"      ) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                   F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''      )

           return cls.from_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )





class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :Union[str, Any]						   =					"align"
       lowerCAmelCase__  :Tuple						   =					True



       def __init__(				self     ,UpperCAmelCase_=None     ,UpperCAmelCase_=None     ,UpperCAmelCase_=640     ,UpperCAmelCase_=1.0     ,UpperCAmelCase_=0.02     ,**UpperCAmelCase_     ,)  ->							Union[str, Any]:
           super().__init__(**UpperCAmelCase_      )

           if text_config is None:
               lowercase__		       =						{}
               logger.info("text_config is None. Initializing the AlignTextConfig with default values."      )

           if vision_config is None:
               lowercase__		       =						{}
               logger.info("vision_config is None. Initializing the AlignVisionConfig with default values."      )

           lowercase__		       =						AlignTextConfig(**UpperCAmelCase_      )
           lowercase__		       =						AlignVisionConfig(**UpperCAmelCase_      )

           lowercase__		       =						projection_dim
           lowercase__		       =						temperature_init_value
           lowercase__		       =						initializer_range



       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							List[str]:
           return cls(text_config=text_config.to_dict()     ,vision_config=vision_config.to_dict()     ,**UpperCAmelCase_      )







       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						copy.deepcopy(self.__dict__      )
           lowercase__		       =						self.text_config.to_dict()
           lowercase__		       =						self.vision_config.to_dict()
           lowercase__		       =						self.__class__.model_type
           return output




