code: 
  import torch
  import trajectory.utils as utils
  
  from transformers import TrajectoryTransformerModel
  
  
  
  
  
  class    _snake_case      (  utils.Parser       ):
     UpperCamelCase__					   =					"halfcheetah-medium-expert-v2"
     UpperCamelCase__					   =					"config.offline"
  
  
  
  
  
  
  
  def 						lowerCAmelCase_		(      _snake_case   :						str   ,     _snake_case   :						Any   ,     _snake_case   :						Optional[Any]   ,     _snake_case   :						Tuple   ,     _snake_case   :						Optional[Any]     )       ->	Optional[int]:
  
  
  
  
  
  
  
   '''simple docstring'''
  
  
   __magic_name__     ,					__magic_name__	:	Optional[Any]			     =  utils.load_model(_snake_case   ,     _snake_case   ,     _snake_case   ,     epoch=_snake_case   ,     device=_snake_case     )
   __magic_name__	:	Optional[int]			     =  TrajectoryTransformerModel(gpt.config     )
  
   trajectory_transformer.tok_emb.load_state_dict(gpt.tok_emb.state_dict()     )
   __magic_name__	:	Dict			     =  gpt.pos_emb
   trajectory_transformer.drop.load_state_dict(gpt.drop.state_dict()     )
   trajectory_transformer.ln_f.load_state_dict(gpt.ln_f.state_dict()     )
   trajectory_transformer.head.load_state_dict(gpt.head.state_dict()     )
  
   for i, block in enumerate(gpt.blocks     ):
    trajectory_transformer.blocks[i].lna.load_state_dict(gpt.blocks[i].lna.state_dict()     )
    trajectory_transformer.blocks[i].lna.load_state_dict(gpt.blocks[i].lna.state_dict()     )
    trajectory_transformer.blocks[i].attn.load_state_dict(gpt.blocks[i].attn.state_dict()     )
  
    trajectory_transformer.blocks[i].la.load_state_dict(gpt.blocks[i].mlp[0].state_dict()     )
    trajectory_transformer.blocks[i].act.load_state_dict(gpt.blocks[i].mlp[1].state_dict()     )
    trajectory_transformer.blocks[i].la.load_state_dict(gpt.blocks[i].mlp[2].state_dict()     )
    trajectory_transformer.blocks[i].drop.load_state_dict(gpt.blocks[i].mlp[3].state_dict()     )
  
   torch.save(trajectory_transformer.state_dict()   ,     "pytorch_model.bin"     )
  
  
  if __name__ == "__main__":
      snake_case				:	int							   =						Parser().parse_args("plan")
      convert_trajectory_transformer_original_pytorch_checkpoint_to_pytorch(
          args.logbase, args.dataset, args.gpt_loadpath, args.gpt_epoch, args.device
      )
  
style_context: 
  def 						lowerCAmelCase_		(      _snake_case   :						int   ,     _snake_case   :						list[tuple[int, int, int]]     )       ->	list[tuple[int, int, int]]:
  
  
  
  
  
  
  
  	'''simple docstring'''
  
  
  	__magic_name__	:	Union[str, Any]			     =  sorted(_snake_case   ,     key=lambda _snake_case     : edge[2]     )
  
  	__magic_name__	:	Union[str, Any]			     =  list(range(_snake_case     )     )
  
  	def find_parent(_snake_case   :						Dict     ):
  		if i != parent[i]:
  			__magic_name__	:	Any			     =  find_parent(parent[i]     )
  		return parent[i]
  
  	__magic_name__	:	List[str]			     =  0
  	__magic_name__	:	int			     =  []
  
  	for edge in edges:
  		__magic_name__	:	Any			     =  find_parent(edge[0]     )
  		__magic_name__	:	int			     =  find_parent(edge[1]     )
  		if parent_a != parent_b:
  			minimum_spanning_tree_cost += edge[2]
  			minimum_spanning_tree.append(_snake_case     )
  			__magic_name__	:	Optional[int]			     =  parent_b
  
  	return minimum_spanning_tree
  
  
  if __name__ == "__main__":  # pragma: no cover
  				snake_case   ,snake_case				:	int							   =						list(map(int, input().strip().split()))
  				snake_case				:	int							   =						[]
  
  				for _ in range(num_edges):
  								snake_case   ,snake_case   ,snake_case				:	Dict							   =						(int(x) for x in input().strip().split())
  								edges.append((nodea, nodea, cost))
  
  				kruskal(num_nodes, edges)
  