






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
   )








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())
