
'''simple docstring'''





import argparse

import torch

from transformers import HubertConfig, HubertForSequenceClassification, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
a__						:				Dict           =    logging.get_logger(__name__)

a__						:				Any           =    ["UtteranceLevel"]





@torch.no_grad()
def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)->     Dict:







						"""simple docstring"""
						__A    		=     torch.load(UpperCAmelCase ,					map_location='cpu'		)
						if checkpoint["Config"]["downstream_expert"]["modelrc"]["select"] not in SUPPORTED_MODELS:
												raise NotImplementedError(f'The supported s3prl models are {SUPPORTED_MODELS}'		)

						__A    		=     checkpoint['Downstream']

						__A    		=     HubertConfig.from_pretrained(UpperCAmelCase		)
						__A    		=     HubertForSequenceClassification.from_pretrained(UpperCAmelCase ,					config=UpperCAmelCase		)
						__A    		=     WavaVecaFeatureExtractor.from_pretrained(
						    UpperCAmelCase ,					return_attention_mask=UpperCAmelCase ,					do_normalize=UpperCAmelCase		)

						if hf_congfig.use_weighted_layer_sum:
												__A    		=     checkpoint['Featurizer']['weights']

						__A    		=     downstream_dict['projector.weight']
						__A    		=     downstream_dict['projector.bias']
						__A    		=     downstream_dict['model.post_net.linear.weight']
						__A    		=     downstream_dict['model.post_net.linear.bias']

						hf_feature_extractor.save_pretrained(UpperCAmelCase		)
						hf_model.save_pretrained(UpperCAmelCase		)


if __name__ == "__main__":
	a__						:				Optional[Any]           =    argparse.ArgumentParser()
	parser.add_argument(
	    "--base_model_name", default=None, type=str, help="Name of the huggingface pretrained base model."
	)
	parser.add_argument("--config_path", default=None, type=str, help="Path to the huggingface classifier config.")
	parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to the s3prl checkpoint.")
	parser.add_argument("--model_dump_path", default=None, type=str, help="Path to the final converted model.")
	a__						:				Optional[int]           =    parser.parse_args()
	convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)








'''simple docstring'''





from __future__ import annotations





def     snake_case							(						UpperCAmelCase		)->     List[Any]:







      """simple docstring"""
      global graph, reversed_graph, scc, component, visit, stack
      if visit[u]:
            return
      __A    		=     True
      for v in graph[u]:
            dfs(UpperCAmelCase		)
      stack.append(UpperCAmelCase		)





def     snake_case							(						UpperCAmelCase		)->     List[Any]:







      """simple docstring"""
      global graph, reversed_graph, scc, component, visit, stack
      if visit[u]:
            return
      __A    		=     True
      component.append(UpperCAmelCase		)
      for v in reversed_graph[u]:
            dfsa(UpperCAmelCase		)





def     snake_case							(						)->     Any:







      """simple docstring"""
      global graph, reversed_graph, scc, component, visit, stack
      for i in range(UpperCAmelCase		):
            dfs(UpperCAmelCase		)
      __A    		=     [False] * n
      for i in stack[::-1]:
            if visit[i]:
                  continue
            __A    		=     []
            dfsa(UpperCAmelCase		)
            scc.append(UpperCAmelCase		)
      return scc


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

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

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






