



'''simple docstring'''






from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A_				:					Optional[Any]							=      logging.get_logger(__name__)

A_				:					List[str]							=      {
    """google/rembert""": """https://huggingface.co/google/rembert/resolve/main/config.json""",
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}



class 				lowercase			(    _lowerCamelCase							):


 """simple docstring"""


 UpperCAmelCase		      =    """rembert"""







 def __init__(				self    ,a_=250_300    ,a_=1_152    ,a_=32    ,a_=18    ,a_=256    ,a_=1_664    ,a_=4_608    ,a_="gelu"    ,a_=0.0    ,a_=0.0    ,a_=0.1    ,a_=512    ,a_=2    ,a_=0.02    ,a_=1E-1_2    ,a_=True    ,a_=0    ,a_=312    ,a_=313    ,**a_    ,)						->  List[Any]:
        super().__init__(pad_token_id=a_    ,bos_token_id=a_    ,eos_token_id=a_    ,**a_				)

        _UpperCAmelCase    :		List[Any]     	=					vocab_size
        _UpperCAmelCase    :		int     	=					input_embedding_size
        _UpperCAmelCase    :		List[str]     	=					output_embedding_size
        _UpperCAmelCase    :		Any     	=					max_position_embeddings
        _UpperCAmelCase    :		Dict     	=					hidden_size
        _UpperCAmelCase    :		Optional[Any]     	=					num_hidden_layers
        _UpperCAmelCase    :		Tuple     	=					num_attention_heads
        _UpperCAmelCase    :		Tuple     	=					intermediate_size
        _UpperCAmelCase    :		str     	=					hidden_act
        _UpperCAmelCase    :		Any     	=					hidden_dropout_prob
        _UpperCAmelCase    :		Optional[int]     	=					attention_probs_dropout_prob
        _UpperCAmelCase    :		Union[str, Any]     	=					classifier_dropout_prob
        _UpperCAmelCase    :		Optional[int]     	=					initializer_range
        _UpperCAmelCase    :		Any     	=					type_vocab_size
        _UpperCAmelCase    :		Optional[int]     	=					layer_norm_eps
        _UpperCAmelCase    :		Union[str, Any]     	=					use_cache
        _UpperCAmelCase    :		Optional[int]     	=					False







class 				lowercase			(    _lowerCamelCase							):


 """simple docstring"""


 @property
 def _snake_case					(				self				)						->  Mapping[str, Mapping[int, str]]:
        if self.task == "multiple-choice":
               _UpperCAmelCase    :		Dict     	=					{0: """batch""", 1: """choice""", 2: """sequence"""}
        else:
               _UpperCAmelCase    :		Dict     	=					{0: """batch""", 1: """sequence"""}
        return OrderedDict(
            [
                ("""input_ids""", dynamic_axis),
                ("""attention_mask""", dynamic_axis),
                ("""token_type_ids""", dynamic_axis),
            ]				)







 @property
 def _snake_case					(				self				)						->  float:
        return 1E-4







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



	"""simple docstring"""






	a_     			=   sorted(UpperCamelCase     ,					key=lambda UpperCamelCase	: edge[2]	)

	a_     			=   list(range(UpperCamelCase	)	)

	def find_parent(UpperCamelCase		:      Any	):
		if i != parent[i]:
			a_     			=   find_parent(parent[i]	)
		return parent[i]

	a_     			=   0
	a_     			=   []

	for edge in edges:
		a_     			=   find_parent(edge[0]	)
		a_     			=   find_parent(edge[1]	)
		if parent_a != parent_b:
			minimum_spanning_tree_cost += edge[2]
			minimum_spanning_tree.append(UpperCamelCase	)
			a_     			=   parent_b

	return minimum_spanning_tree


if __name__ == "__main__":  # pragma: no cover
			_A     ,				_A							     =       list(map(int, input().strip().split()))
			_A							     =       []

			for _ in range(num_edges):
						_A     ,				_A     ,				_A							     =       (int(x) for x in input().strip().split())
						edges.append((nodea, nodea, cost))

			kruskal(num_nodes, edges)