code: 
  
  
  
  
  
  
  import torch
  import trajectory.utils as utils
  
  from transformers import TrajectoryTransformerModel
  
  class 					snake_case_							(       utils.Parser      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     __lowerCAmelCase      =						"halfcheetah-medium-expert-v2"
     __lowerCAmelCase      =						"config.offline"
  
  
  
  
  
  
  def        UpperCAmelCase      (   _lowercase,      _lowercase,      _lowercase,      _lowercase,      _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase ,    _lowercase     =	utils.load_model(_lowercase,      _lowercase,      _lowercase,      epoch=_lowercase,      device=_lowercase      )
      _lowercase     =	TrajectoryTransformerModel(gpt.config      )
  
      trajectory_transformer.tok_emb.load_state_dict(gpt.tok_emb.state_dict()      )
      _lowercase     =	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__":
     lowerCamelCase										=  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: 
  
  
  
  
  
  
  from __future__ import annotations
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      global graph, reversed_graph, scc, component, visit, stack
      if visit[u]:
          return
      _lowercase     =	True
      for v in graph[u]:
          dfs(_lowercase      )
      stack.append(_lowercase      )
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      global graph, reversed_graph, scc, component, visit, stack
      if visit[u]:
          return
      _lowercase     =	True
      component.append(_lowercase      )
      for v in reversed_graph[u]:
          dfsa(_lowercase      )
  def        UpperCAmelCase      (   ):
  
  
      '''simple docstring'''
  
  
  
      global graph, reversed_graph, scc, component, visit, stack
      for i in range(_lowercase      ):
          dfs(_lowercase      )
      _lowercase     =	[False] * n
      for i in stack[::-1]:
          if visit[i]:
              continue
          _lowercase     =	[]
          dfsa(_lowercase      )
          scc.append(_lowercase      )
      return scc
  
  
  if __name__ == "__main__":
     # n - no of nodes, m - no of edges
     lowerCamelCase						,		lowerCamelCase										=  list(map(int, input().strip().split()))
  
     lowerCamelCase										=  [[] for _ in range(n)]  # graph
     lowerCamelCase										=  [[] for i in range(n)]  # reversed graph
     # input graph data (edges)
     for _ in range(m):
        lowerCamelCase						,		lowerCamelCase										=  list(map(int, input().strip().split()))
        graph[u].append(v)
        reversed_graph[v].append(u)
  
     lowerCamelCase										=  []
     lowerCamelCase										=  [False] * n
     lowerCamelCase										=  []
     lowerCamelCase										=  []
     print(kosaraju())
  