code: 
  
  
  
  
  
  
  import collections
  import inspect
  import unittest
  
  from transformers import DinatConfig
  from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
  from transformers.utils import cached_property, is_torch_available, is_vision_available
  
  from ...test_backbone_common import BackboneTesterMixin
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
     import torch
     from torch import nn
  
     from transformers import DinatBackbone, DinatForImageClassification, DinatModel
     from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST
  
  if is_vision_available():
     from PIL import Image
  
     from transformers import AutoImageProcessor
  
  class 					snake_case_							:
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def __init__(    self:	Optional[int]   ,       snake_case__:	Dict   ,       snake_case__:	Tuple=13   ,       snake_case__:	List[Any]=64   ,       snake_case__:	Dict=4   ,       snake_case__:	Optional[int]=3   ,       snake_case__:	Union[str, Any]=16   ,       snake_case__:	List[str]=[1, 2, 1]   ,       snake_case__:	Tuple=[2, 4, 8]   ,       snake_case__:	Any=3   ,       snake_case__:	Dict=[[3], [1, 2], [1]]   ,       snake_case__:	Union[str, Any]=2.0   ,       snake_case__:	Dict=True   ,       snake_case__:	Tuple=0.0   ,       snake_case__:	int=0.0   ,       snake_case__:	List[Any]=0.1   ,       snake_case__:	Optional[int]="gelu"   ,       snake_case__:	List[str]=True   ,       snake_case__:	int=0.02   ,       snake_case__:	List[Any]=1E-5   ,       snake_case__:	List[Any]=True   ,       snake_case__:	Union[str, Any]=None   ,       snake_case__:	Union[str, Any]=True   ,       snake_case__:	Any=10   ,       snake_case__:	Optional[Any]=["stage1", "stage2"]   ,       snake_case__:	str=[1, 2]   ,       )  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	parent
         _lowercase     =	batch_size
         _lowercase     =	image_size
         _lowercase     =	patch_size
         _lowercase     =	num_channels
         _lowercase     =	embed_dim
         _lowercase     =	depths
         _lowercase     =	num_heads
         _lowercase     =	kernel_size
         _lowercase     =	dilations
         _lowercase     =	mlp_ratio
         _lowercase     =	qkv_bias
         _lowercase     =	hidden_dropout_prob
         _lowercase     =	attention_probs_dropout_prob
         _lowercase     =	drop_path_rate
         _lowercase     =	hidden_act
         _lowercase     =	patch_norm
         _lowercase     =	layer_norm_eps
         _lowercase     =	initializer_range
         _lowercase     =	is_training
         _lowercase     =	scope
         _lowercase     =	use_labels
         _lowercase     =	num_labels
         _lowercase     =	out_features
         _lowercase     =	out_indices
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		Dict:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)
  
         _lowercase     =	None
         if self.use_labels:
             _lowercase     =	ids_tensor([self.batch_size]   ,       self.num_labels	)
  
         _lowercase     =	self.get_config()
  
         return config, pixel_values, labels
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         return DinatConfig(
             num_labels=self.num_labels   ,       image_size=self.image_size   ,       patch_size=self.patch_size   ,       num_channels=self.num_channels   ,       embed_dim=self.embed_dim   ,       depths=self.depths   ,       num_heads=self.num_heads   ,       kernel_size=self.kernel_size   ,       dilations=self.dilations   ,       mlp_ratio=self.mlp_ratio   ,       qkv_bias=self.qkv_bias   ,       hidden_dropout_prob=self.hidden_dropout_prob   ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,       drop_path_rate=self.drop_path_rate   ,       hidden_act=self.hidden_act   ,       patch_norm=self.patch_norm   ,       layer_norm_eps=self.layer_norm_eps   ,       initializer_range=self.initializer_range   ,       out_features=self.out_features   ,       out_indices=self.out_indices   ,       )
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple   ,       snake_case__:	Optional[int]   ,       snake_case__:	int   ,       snake_case__:	Union[str, Any]	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	DinatModel(config=snake_case__	)
         model.to(snake_case__	)
         model.eval()
         _lowercase     =	model(snake_case__	)
  
         _lowercase     =	_lowercase     =	(config.image_size // config.patch_size) // (2 ** (len(config.depths	) - 1))
         _lowercase     =	int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)
  
         self.parent.assertEqual(
             result.last_hidden_state.shape   ,       (self.batch_size, expected_height, expected_width, expected_dim)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	int   ,       snake_case__:	Tuple   ,       snake_case__:	Union[str, Any]   ,       snake_case__:	Optional[int]	)  ->		str:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	DinatForImageClassification(snake_case__	)
         model.to(snake_case__	)
         model.eval()
         _lowercase     =	model(snake_case__   ,       labels=snake_case__	)
         self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_labels)	)
  
         # test greyscale images
         _lowercase     =	1
         _lowercase     =	DinatForImageClassification(snake_case__	)
         model.to(snake_case__	)
         model.eval()
  
         _lowercase     =	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
         _lowercase     =	model(snake_case__	)
         self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_labels)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]   ,       snake_case__:	int   ,       snake_case__:	Tuple   ,       snake_case__:	Union[str, Any]	)  ->		Optional[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	DinatBackbone(config=snake_case__	)
         model.to(snake_case__	)
         model.eval()
         _lowercase     =	model(snake_case__	)
  
         # verify hidden states
         self.parent.assertEqual(len(result.feature_maps	)   ,       len(config.out_features	)	)
         self.parent.assertListEqual(list(result.feature_maps[0].shape	)   ,       [self.batch_size, model.channels[0], 16, 16]	)
  
         # verify channels
         self.parent.assertEqual(len(model.channels	)   ,       len(config.out_features	)	)
  
         # verify backbone works with out_features=None
         _lowercase     =	None
         _lowercase     =	DinatBackbone(config=snake_case__	)
         model.to(snake_case__	)
         model.eval()
         _lowercase     =	model(snake_case__	)
  
         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps	)   ,       1	)
         self.parent.assertListEqual(list(result.feature_maps[0].shape	)   ,       [self.batch_size, model.channels[-1], 4, 4]	)
  
         # verify channels
         self.parent.assertEqual(len(model.channels	)   ,       1	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.prepare_config_and_inputs()
         _lowercase ,    _lowercase ,    _lowercase     =	config_and_inputs
         _lowercase     =	{'pixel_values': pixel_values}
         return config, inputs_dict
  
  
  
  
  
  
  @require_natten
  @require_torch
  class 					snake_case_							(       lowercase_      ,			lowercase_      ,			unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     __lowerCAmelCase      =						(
         (
             DinatModel,
             DinatForImageClassification,
             DinatBackbone,
         )
         if is_torch_available()
         else ()
     )
     __lowerCAmelCase      =						(
         {"""feature-extraction""": DinatModel, """image-classification""": DinatForImageClassification}
         if is_torch_available()
         else {}
     )
     __lowerCAmelCase      =						False
  
     __lowerCAmelCase      =						False
     __lowerCAmelCase      =						False
     __lowerCAmelCase      =						False
     __lowerCAmelCase      =						False
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	DinatModelTester(self	)
         _lowercase     =	ConfigTester(self   ,       config_class=snake_case__   ,       embed_dim=37	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[Any]	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         return
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		str:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*snake_case__	)
  
     @unittest.skip(reason='Dinat does not use inputs_embeds'	)
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         pass
  
     @unittest.skip(reason='Dinat does not use feedforward chunking'	)
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		str:
  
  
         """simple docstring"""
  
  
  
         pass
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase ,    _lowercase     =	self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
             _lowercase     =	model_class(snake_case__	)
             self.assertIsInstance(model.get_input_embeddings()   ,       (nn.Module)	)
             _lowercase     =	model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(snake_case__   ,       nn.Linear	)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase ,    _lowercase     =	self.model_tester.prepare_config_and_inputs_for_common()
  
         for model_class in self.all_model_classes:
             _lowercase     =	model_class(snake_case__	)
             _lowercase     =	inspect.signature(model.forward	)
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             _lowercase     =	[*signature.parameters.keys()]
  
             _lowercase     =	['pixel_values']
             self.assertListEqual(arg_names[:1]   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         self.skipTest('Dinat\'s attention operation is handled entirely by NATTEN.'	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]   ,       snake_case__:	Optional[int]   ,       snake_case__:	Optional[int]   ,       snake_case__:	Any   ,       snake_case__:	Any	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	model_class(snake_case__	)
         model.to(snake_case__	)
         model.eval()
  
         with torch.no_grad():
             _lowercase     =	model(**self._prepare_for_class(snake_case__   ,       snake_case__	)	)
  
         _lowercase     =	outputs.hidden_states
  
         _lowercase     =	getattr(
             self.model_tester   ,       'expected_num_hidden_layers'   ,       len(self.model_tester.depths	) + 1	)
         self.assertEqual(len(snake_case__	)   ,       snake_case__	)
  
         # Dinat has a different seq_length
         _lowercase     =	(
             config.patch_size
             if isinstance(config.patch_size   ,       collections.abc.Iterable	)
             else (config.patch_size, config.patch_size)
         )
  
         _lowercase     =	image_size[0] // patch_size[0]
         _lowercase     =	image_size[1] // patch_size[1]
  
         self.assertListEqual(
             list(hidden_states[0].shape[-3:]	)   ,       [height, width, self.model_tester.embed_dim]   ,       )
  
         if model_class.__name__ != "DinatBackbone":
             _lowercase     =	outputs.reshaped_hidden_states
             self.assertEqual(len(snake_case__	)   ,       snake_case__	)
  
             _lowercase ,    _lowercase ,    _lowercase ,    _lowercase     =	reshaped_hidden_states[0].shape
             _lowercase     =	(
                 reshaped_hidden_states[0].view(snake_case__   ,       snake_case__   ,       snake_case__   ,       snake_case__	).permute(0   ,       2   ,       3   ,       1	)
             )
             self.assertListEqual(
                 list(reshaped_hidden_states.shape[-3:]	)   ,       [height, width, self.model_tester.embed_dim]   ,       )
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	str	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase ,    _lowercase     =	self.model_tester.prepare_config_and_inputs_for_common()
  
         _lowercase     =	(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size   ,       collections.abc.Iterable	)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
  
         for model_class in self.all_model_classes:
             _lowercase     =	True
             self.check_hidden_states_output(snake_case__   ,       snake_case__   ,       snake_case__   ,       snake_case__	)
  
             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             _lowercase     =	True
  
             self.check_hidden_states_output(snake_case__   ,       snake_case__   ,       snake_case__   ,       snake_case__	)
  
     @slow
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _lowercase     =	DinatModel.from_pretrained(snake_case__	)
             self.assertIsNotNone(snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase ,    _lowercase     =	self.model_tester.prepare_config_and_inputs_for_common()
  
         _lowercase     =	_config_zero_init(snake_case__	)
         for model_class in self.all_model_classes:
             _lowercase     =	model_class(config=snake_case__	)
             for name, param in model.named_parameters():
                 if "embeddings" not in name and param.requires_grad:
                     self.assertIn(
                         ((param.data.mean() * 1E9).round() / 1E9).item()   ,       [0.0, 1.0]   ,       msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''   ,       )
  
  
  
  
  
  
  @require_natten
  @require_vision
  @require_torch
  class 					snake_case_							(       unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     @cached_property
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         return AutoImageProcessor.from_pretrained('shi-labs/dinat-mini-in1k-224'	) if is_vision_available() else None
  
     @slow
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		Tuple:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	DinatForImageClassification.from_pretrained('shi-labs/dinat-mini-in1k-224'	).to(snake_case__	)
         _lowercase     =	self.default_image_processor
  
         _lowercase     =	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
         _lowercase     =	image_processor(images=snake_case__   ,       return_tensors='pt'	).to(snake_case__	)
  
         # forward pass
         with torch.no_grad():
             _lowercase     =	model(**snake_case__	)
  
         # verify the logits
         _lowercase     =	torch.Size((1, 1_000)	)
         self.assertEqual(outputs.logits.shape   ,       snake_case__	)
         _lowercase     =	torch.tensor([-0.15_45, -0.76_67, 0.46_42]	).to(snake_case__	)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,       snake_case__   ,       atol=1E-4	)	)
  
  
  
  
  
  
  @require_torch
  @require_natten
  class 					snake_case_							(       unittest.TestCase      ,			lowercase_      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     __lowerCAmelCase      =						(DinatBackbone,) if is_torch_available() else ()
     __lowerCAmelCase      =						DinatConfig
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	DinatModelTester(self	)
  
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())
  