
import argparse
import json

from transformers import GPTNeoConfig, GPTNeoForCausalLM, load_tf_weights_in_gpt_neo
from transformers.utils import logging


logging.set_verbosity_info()






def     lowerCamelCase__				(   a						,						a						,						a ) ->  Optional[Any]:
   # Initialise PyTorch model
   _A:    Optional[int]						     =			json.load(open(a						,						'''r''' ) )
   _A:    int						     =			GPTNeoConfig(
       hidden_size=config_json['''n_embd''']						,						num_layers=config_json['''n_layer''']						,						num_heads=config_json['''n_head''']						,						attention_types=config_json['''attention_types''']						,						max_position_embeddings=config_json['''n_positions''']						,						resid_dropout=config_json['''res_dropout''']						,						embed_dropout=config_json['''embed_dropout''']						,						attention_dropout=config_json['''attn_dropout''']						,						)
   print(f"""Building PyTorch model from configuration: {config}""" )
   _A:    List[Any]						     =			GPTNeoForCausalLM(a )

   # Load weights from tf checkpoint
   load_tf_weights_in_gpt_neo(a						,						a						,						a )

   # Save pytorch-model
   print(f"""Save PyTorch model to {pytorch_dump_path}""" )
   model.save_pretrained(a )


if __name__ == "__main__":
   UpperCAmelCase__						:	int	     = argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--tf_checkpoint_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 mesh-tf 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.'
   )
   UpperCAmelCase__						:	str	     = parser.parse_args()
   convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)





from __future__ import annotations






def     lowerCamelCase__				(   a ) ->  Union[str, Any]:
   global graph, reversed_graph, scc, component, visit, stack
   if visit[u]:
      return
   _A:    Optional[Any]						     =			True
   for v in graph[u]:
      dfs(a )
   stack.append(a )






def     lowerCamelCase__				(   a ) ->  List[Any]:
   global graph, reversed_graph, scc, component, visit, stack
   if visit[u]:
      return
   _A:    str						     =			True
   component.append(a )
   for v in reversed_graph[u]:
      dfsa(a )






def     lowerCamelCase__				(   ) ->  str:
   global graph, reversed_graph, scc, component, visit, stack
   for i in range(a ):
      dfs(a )
   _A:    Optional[Any]						     =			[False] * n
   for i in stack[::-1]:
      if visit[i]:
         continue
      _A:    Optional[Any]						     =			[]
      dfsa(a )
      scc.append(a )
   return scc


if __name__ == "__main__":
   # n - no of nodes, m - no of edges
   UpperCAmelCase__     ,UpperCAmelCase__						:	Any	     = list(map(int, input().strip().split()))

   UpperCAmelCase__						:	list[list[int]]	     = [[] for _ in range(n)]  # graph
   UpperCAmelCase__						:	list[list[int]]	     = [[] for i in range(n)]  # reversed graph
   # input graph data (edges)
   for _ in range(m):
      UpperCAmelCase__     ,UpperCAmelCase__						:	str	     = list(map(int, input().strip().split()))
      graph[u].append(v)
      reversed_graph[v].append(u)

   UpperCAmelCase__						:	list[int]	     = []
   UpperCAmelCase__						:	list[bool]	     = [False] * n
   UpperCAmelCase__						:	list[int]	     = []
   UpperCAmelCase__						:	list[int]	     = []
   print(kosaraju())



