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






class 			__lowercase		:







     """simple docstring"""






     def __init__(		self    ):
         __UpperCamelCase	:	Any		    =  []







     def lowerCAmelCase     (		self     ,			_lowerCamelCase    ):
         return self.node_position[vertex]







     def lowerCAmelCase     (		self     ,			_lowerCamelCase     ,			_lowerCamelCase    ):
         __UpperCamelCase	:	Optional[int]		    =  pos







     def lowerCAmelCase     (		self     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase    ):
         if start > size // 2 - 1:
             return
         else:
             if 2 * start + 2 >= size:
                 __UpperCamelCase	:	Optional[Any]		    =  2 * start + 1
             else:
                 if heap[2 * start + 1] < heap[2 * start + 2]:
                     __UpperCamelCase	:	int		    =  2 * start + 1
                 else:
                     __UpperCamelCase	:	Optional[int]		    =  2 * start + 2
             if heap[smallest_child] < heap[start]:
                 __UpperCamelCase	:	Dict		    =  heap[smallest_child], positions[smallest_child]
                 __UpperCamelCase	:	Optional[int]		    =  (
                     heap[start],
                     positions[start],
                 )
                 __UpperCamelCase	:	List[str]		    =  temp, tempa

                 __UpperCamelCase	:	str		    =  self.get_position(positions[smallest_child]    )
                 self.set_position(
                     positions[smallest_child]     ,			self.get_position(positions[start]    )    )
                 self.set_position(positions[start]     ,			_lowerCamelCase    )

                 self.top_to_bottom(_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase    )







     def lowerCAmelCase     (		self     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase     ,			_lowerCamelCase    ):
         __UpperCamelCase	:	Dict		    =  position[index]

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

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







     def lowerCAmelCase     (		self     ,			_lowerCamelCase     ,			_lowerCamelCase    ):
         __UpperCamelCase	:	Dict		    =  len(_lowerCamelCase    ) // 2 - 1
         for i in range(_lowerCamelCase     ,			-1     ,			-1    ):
             self.top_to_bottom(_lowerCamelCase     ,			_lowerCamelCase     ,			len(_lowerCamelCase    )     ,			_lowerCamelCase    )







     def lowerCAmelCase     (		self     ,			_lowerCamelCase     ,			_lowerCamelCase    ):
         __UpperCamelCase	:	Union[str, Any]		    =  positions[0]
         __UpperCamelCase	:	List[str]		    =  sys.maxsize
         self.top_to_bottom(_lowerCamelCase     ,			0     ,			len(_lowerCamelCase    )     ,			_lowerCamelCase    )
         return temp







def  _UpperCamelCase (		_a	:	int			):




    """simple docstring"""



    __UpperCamelCase	:	List[Any]		    =  Heap()

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

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

    __UpperCamelCase	:	Tuple		    =  []
    __UpperCamelCase	:	Dict		    =  1
    __UpperCamelCase	:	int		    =  sys.maxsize
    for neighbor, distance in adjacency_list[0]:
        __UpperCamelCase	:	Dict		    =  0
        __UpperCamelCase	:	Tuple		    =  distance
    heap.heapify(_a				,     _a			)

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


if __name__ == "__main__":  # pragma: no cover
  # < --------- Prims Algorithm --------- >
  a=  int(input('''Enter number of edges: ''').strip())
  a=  defaultdict(list)
  for _ in range(edges_number):
    a=  [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 argparse
import pickle

import numpy as np
import torch
from torch import nn

from transformers import ReformerConfig, ReformerModelWithLMHead
from transformers.utils import logging


logging.set_verbosity_info()







def  _UpperCamelCase (     _a	:	int				,     _a	:	Tuple				,     _a	:	Dict=None			):




    """simple docstring"""



    assert torch_layer.weight.shape == weight.shape, f"""{torch_layer} layer.weight does not match"""
    __UpperCamelCase	:	List[Any]		    =  nn.Parameter(_a			)
    if bias is not None:
        assert torch_layer.bias.shape == bias.shape, f"""{torch_layer} layer.bias does not match"""
        __UpperCamelCase	:	Dict		    =  nn.Parameter(_a			)







def  _UpperCamelCase (     _a	:	Tuple				,     _a	:	str				,     _a	:	List[str]			):




    """simple docstring"""



    __UpperCamelCase	:	List[Any]		    =  np.asarray(weights[0]			)
    __UpperCamelCase	:	str		    =  np.asarray(weights[1]			)
    __UpperCamelCase	:	Optional[int]		    =  np.asarray(weights[2]			)

    set_param(
        torch_layer.self_attention.query_key				,     torch.tensor(_a			).transpose(1				,     2			).contiguous().view(-1				,     _a			)				,     )
    set_param(
        torch_layer.self_attention.value				,     torch.tensor(_a			).transpose(1				,     2			).contiguous().view(-1				,     _a			)				,     )
    set_param(
        torch_layer.output.dense				,     torch.tensor(_a			).view(-1				,     _a			).contiguous().transpose(0				,     1			)				,     )







def  _UpperCamelCase (     _a	:	Union[str, Any]				,     _a	:	Any				,     _a	:	List[Any]			):




    """simple docstring"""



    __UpperCamelCase	:	Optional[int]		    =  np.asarray(weights[0]			)
    __UpperCamelCase	:	Tuple		    =  np.asarray(weights[1]			)
    __UpperCamelCase	:	Tuple		    =  np.asarray(weights[2]			)
    __UpperCamelCase	:	Optional[int]		    =  np.asarray(weights[3]			)

    set_param(
        torch_layer.self_attention.query				,     torch.tensor(_a			).transpose(1				,     2			).contiguous().view(-1				,     _a			)				,     )
    set_param(
        torch_layer.self_attention.key				,     torch.tensor(_a			).transpose(1				,     2			).contiguous().view(-1				,     _a			)				,     )
    set_param(
        torch_layer.self_attention.value				,     torch.tensor(_a			).transpose(1				,     2			).contiguous().view(-1				,     _a			)				,     )
    set_param(
        torch_layer.output.dense				,     torch.tensor(_a			).view(-1				,     _a			).contiguous().transpose(0				,     1			)				,     )







def  _UpperCamelCase (     _a	:	Dict				,     _a	:	str				,     _a	:	List[Any]			):




    """simple docstring"""



    __UpperCamelCase	:	Optional[Any]		    =  weights[0][0][0]
    __UpperCamelCase	:	Tuple		    =  np.asarray(layer_norm_a[0]			)
    __UpperCamelCase	:	List[str]		    =  np.asarray(layer_norm_a[1]			)
    set_param(
        torch_block.attention.layer_norm				,     torch.tensor(_a			)				,     torch.tensor(_a			)				,     )

    # lsh weights + output
    __UpperCamelCase	:	int		    =  weights[0][1]
    if len(_a			) < 4:
        set_layer_weights_in_torch_lsh(_a				,     torch_block.attention				,     _a			)
    else:
        set_layer_weights_in_torch_local(_a				,     torch_block.attention				,     _a			)

    # intermediate weighs
    __UpperCamelCase	:	int		    =  weights[2][0][1][2]

    # Chunked Feed Forward
    if len(_a			) == 4:
        __UpperCamelCase	:	Optional[Any]		    =  intermediate_weights[2]

    # layernorm 2
    __UpperCamelCase	:	int		    =  np.asarray(intermediate_weights[0][0]			)
    __UpperCamelCase	:	Tuple		    =  np.asarray(intermediate_weights[0][1]			)
    set_param(
        torch_block.feed_forward.layer_norm				,     torch.tensor(_a			)				,     torch.tensor(_a			)				,     )

    # intermediate dense
    __UpperCamelCase	:	Optional[Any]		    =  np.asarray(intermediate_weights[1][0]			)
    __UpperCamelCase	:	int		    =  np.asarray(intermediate_weights[1][1]			)
    set_param(
        torch_block.feed_forward.dense.dense				,     torch.tensor(_a			).transpose(0				,     1			).contiguous()				,     torch.tensor(_a			)				,     )

    # intermediate out
    __UpperCamelCase	:	Dict		    =  np.asarray(intermediate_weights[4][0]			)
    __UpperCamelCase	:	List[str]		    =  np.asarray(intermediate_weights[4][1]			)
    set_param(
        torch_block.feed_forward.output.dense				,     torch.tensor(_a			).transpose(0				,     1			).contiguous()				,     torch.tensor(_a			)				,     )







def  _UpperCamelCase (     _a	:	int				,     _a	:	str				,     _a	:	Union[str, Any]			):




    """simple docstring"""



    __UpperCamelCase	:	Union[str, Any]		    =  torch_model.reformer

    # word embeds
    __UpperCamelCase	:	Tuple		    =  np.asarray(weights[1]			)
    set_param(
        torch_model_reformer.embeddings.word_embeddings				,     torch.tensor(_a			)				,     )

    if isinstance(weights[3]				,     _a			):
        __UpperCamelCase	:	Dict		    =  torch_model_reformer.embeddings.position_embeddings
        for emb_idx in range(len(position_embeddings.weights			)			):
            __UpperCamelCase	:	str		    =  np.asarray(weights[3][emb_idx][0]			)
            assert (
                position_embeddings.weights[emb_idx].shape == emb_weights.shape
            ), f"""{position_embeddings[emb_idx]} emb does not match"""
            __UpperCamelCase	:	Tuple		    =  nn.Parameter(torch.tensor(_a			)			)

    __UpperCamelCase	:	int		    =  weights[5]
    assert len(torch_model_reformer.encoder.layers			) * 4 == len(
        _a			), "HF and trax model do not have the same number of layers"
    for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers			):
        __UpperCamelCase	:	Any		    =  trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
        set_block_weights_in_torch(_a				,     _a				,     _a			)

    # output layer norm
    __UpperCamelCase	:	Optional[Any]		    =  np.asarray(weights[7][0]			)
    __UpperCamelCase	:	Any		    =  np.asarray(weights[7][1]			)
    set_param(
        torch_model_reformer.encoder.layer_norm				,     torch.tensor(_a			)				,     torch.tensor(_a			)				,     )

    # output embeddings
    __UpperCamelCase	:	List[Any]		    =  np.asarray(weights[9][0]			)
    __UpperCamelCase	:	Union[str, Any]		    =  np.asarray(weights[9][1]			)
    set_param(
        torch_model.lm_head.decoder				,     torch.tensor(_a			).transpose(0				,     1			).contiguous()				,     torch.tensor(_a			)				,     )







def  _UpperCamelCase (     _a	:	Optional[int]				,     _a	:	List[Any]				,     _a	:	Optional[Any]			):




    """simple docstring"""



    __UpperCamelCase	:	str		    =  ReformerConfig.from_json_file(_a			)
    print(f"""Building PyTorch model from configuration: {config}"""			)
    __UpperCamelCase	:	List[str]		    =  ReformerModelWithLMHead(_a			)

    with open(_a				,     'rb'			) as f:
        __UpperCamelCase	:	Tuple		    =  pickle.load(_a			)['weights']

    set_model_weights_in_torch(_a				,     _a				,     config.hidden_size			)

    # Save pytorch-model
    print(f"""Save PyTorch model to {pytorch_dump_path}"""			)
    torch.save(model.state_dict()				,     _a			)


if __name__ == "__main__":
  a=  argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--trax_model_pkl_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
  )
  parser.add_argument(
      '''--config_file''',
      default=None,
      type=str,
      required=True,
      help=(
          '''The config json file corresponding to the pre-trained Reformer model. \n'''
          '''This specifies the model architecture.'''
      ),
  )
  parser.add_argument(
      '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
  )
  a=  parser.parse_args()
  convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)



