

'''simple docstring'''
import sys
from collections import defaultdict







class 							A__   :





  def __init__(		self				:     Optional[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =[]





  def 						A  (		self				:     Tuple							, _a				:     Dict			)     ->   Tuple:





       '''simple docstring'''






       return self.node_position[vertex]





  def 						A  (		self				:     List[str]							, _a				:     Optional[int]							, _a				:     Any			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =pos





  def 						A  (		self				:     Any							, _a				:     Tuple							, _a				:     Optional[Any]							, _a				:     Tuple							, _a				:     Optional[Any]			)     ->   str:





       '''simple docstring'''






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

                 _SCREAMING_SNAKE_CASE							   =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 						A  (		self				:     List[Any]							, _a				:     Dict							, _a				:     int							, _a				:     Union[str, Any]							, _a				:     int			)     ->   Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =position[index]

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

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





  def 						A  (		self				:     Union[str, Any]							, _a				:     int							, _a				:     Any			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =len(_a			) // 2 - 1
       for i in range(_a							, -1							, -1			):
            self.top_to_bottom(_a							, _a							, len(_a			)							, _a			)





  def 						A  (		self				:     List[Any]							, _a				:     Optional[Any]							, _a				:     str			)     ->   int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =positions[0]
       _SCREAMING_SNAKE_CASE							   =sys.maxsize
       self.top_to_bottom(_a							, 0							, len(_a			)							, _a			)
       return temp


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[Any]    )				->      Any:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =Heap()

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

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

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

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


if __name__ == "__main__":  # pragma: no cover
     # < --------- Prims Algorithm --------- >
     lowerCamelCase			:				Optional[Any] 			=					int(input("Enter number of edges: ").strip())
     lowerCamelCase			:				Optional[Any] 			=					defaultdict(list)
     for _ in range(edges_number):
          lowerCamelCase			:				int 			=					[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'''
from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


lowerCamelCase			:				List[Any] 			=					"\\n@inproceedings{wang2019glue,\n  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},\n  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},\n  note={In the Proceedings of ICLR.},\n  year={2019}\n}\n"

lowerCamelCase			:				List[str] 			=					"\\nGLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n"

lowerCamelCase			:				Dict 			=					"\nCompute GLUE evaluation metric associated to each GLUE dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\nReturns: depending on the GLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"pearson\": Pearson Correlation\n    \"spearmanr\": Spearman Correlation\n    \"matthews_correlation\": Matthew Correlation\nExamples:\n\n    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'stsb')\n    >>> references = [0., 1., 2., 3., 4., 5.]\n    >>> predictions = [0., 1., 2., 3., 4., 5.]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})\n    {'pearson': 1.0, 'spearmanr': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'cola')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"


def 	_lowerCAmelCase (						_UpperCamelCase						:					List[Any]							,			_UpperCamelCase						:					Dict    )				->      List[str]:
     """simple docstring"""




     return float((preds == labels).mean()    )


def 	_lowerCAmelCase (						_UpperCamelCase						:					Dict							,			_UpperCamelCase						:					Any    )				->      Tuple:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =simple_accuracy(_UpperCamelCase							,			_UpperCamelCase    )
     _SCREAMING_SNAKE_CASE							   =float(fa_score(y_true=_UpperCamelCase							,			y_pred=_UpperCamelCase    )    )
     return {
         "accuracy": acc,
         "f1": fa,
     }


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[int]							,			_UpperCamelCase						:					Optional[int]    )				->      Dict:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =float(pearsonr(_UpperCamelCase							,			_UpperCamelCase    )[0]    )
     _SCREAMING_SNAKE_CASE							   =float(spearmanr(_UpperCamelCase							,			_UpperCamelCase    )[0]    )
     return {
         "pearson": pearson_corr,
         "spearmanr": spearman_corr,
     }







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION					,       _KWARGS_DESCRIPTION  )
class 							A__   (	datasets.Metric  ):





  def 						A  (		self				:     Optional[int]			)     ->   Any:





       '''simple docstring'''






       if self.config_name not in [
           "sst2",
           "mnli",
           "mnli_mismatched",
           "mnli_matched",
           "cola",
           "stsb",
           "mrpc",
           "qqp",
           "qnli",
           "rte",
           "wnli",
           "hans",
       ]:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'			)
       return datasets.MetricInfo(
           description=_DESCRIPTION							, citation=_CITATION							, inputs_description=_KWARGS_DESCRIPTION							, features=datasets.Features(
               {
                   'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'			),
                   'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'			),
               }			)							, codebase_urls=[]							, reference_urls=[]							, format='numpy'							, )





  def 						A  (		self				:     str							, _a				:     str							, _a				:     List[Any]			)     ->   str:





       '''simple docstring'''






       if self.config_name == "cola":
            return {"matthews_correlation": matthews_corrcoef(_a							, _a			)}
       elif self.config_name == "stsb":
            return pearson_and_spearman(_a							, _a			)
       elif self.config_name in ["mrpc", "qqp"]:
            return acc_and_fa(_a							, _a			)
       elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
            return {"accuracy": simple_accuracy(_a							, _a			)}
       else:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'			)
