import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
    from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import PoolFormerImageProcessor
class        a_				(		SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 def 	__snake_case		(    self      :						List[str]):







        '''simple docstring'''



        lowerCAmelCase__  			=      self.config_class(**self.inputs_dict)
        self.parent.assertTrue(hasattr(lowercase__    ,					'hidden_sizes'))
        self.parent.assertTrue(hasattr(lowercase__    ,					'num_encoder_blocks'))






class        a_				:






 '''simple docstring'''






 def __init__(    self      :						str    ,					lowercase__      :						str    ,					lowercase__      :						Optional[int]=13    ,					lowercase__      :						str=64    ,					lowercase__      :						Union[str, Any]=3    ,					lowercase__      :						str=4    ,					lowercase__      :						Any=[2, 2, 2, 2]    ,					lowercase__      :						str=[8, 4, 2, 1]    ,					lowercase__      :						List[Any]=[16, 32, 64, 128]    ,					lowercase__      :						Any=[1, 4, 8, 16]    ,					lowercase__      :						Tuple=False    ,					lowercase__      :						Optional[int]=True    ,					lowercase__      :						Dict="gelu"    ,					lowercase__      :						Tuple=0.1    ,					lowercase__      :						Optional[int]=0.02    ,					lowercase__      :						Dict=3    ,					lowercase__      :						Union[str, Any]=None    ,					):







        '''simple docstring'''



        lowerCAmelCase__  			=      parent
        lowerCAmelCase__  			=      batch_size
        lowerCAmelCase__  			=      image_size
        lowerCAmelCase__  			=      num_channels
        lowerCAmelCase__  			=      num_encoder_blocks
        lowerCAmelCase__  			=      sr_ratios
        lowerCAmelCase__  			=      depths
        lowerCAmelCase__  			=      hidden_sizes
        lowerCAmelCase__  			=      downsampling_rates
        lowerCAmelCase__  			=      is_training
        lowerCAmelCase__  			=      use_labels
        lowerCAmelCase__  			=      hidden_act
        lowerCAmelCase__  			=      hidden_dropout_prob
        lowerCAmelCase__  			=      initializer_range
        lowerCAmelCase__  			=      num_labels
        lowerCAmelCase__  			=      scope




 def 	__snake_case		(    self      :						str):







        '''simple docstring'''



        lowerCAmelCase__  			=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

        lowerCAmelCase__  			=      None
        if self.use_labels:
               lowerCAmelCase__  			=      ids_tensor([self.batch_size, self.image_size, self.image_size]    ,					self.num_labels)

        lowerCAmelCase__  			=      PoolFormerConfig(
            image_size=self.image_size    ,					num_channels=self.num_channels    ,					num_encoder_blocks=self.num_encoder_blocks    ,					depths=self.depths    ,					hidden_sizes=self.hidden_sizes    ,					hidden_act=self.hidden_act    ,					hidden_dropout_prob=self.hidden_dropout_prob    ,					initializer_range=self.initializer_range    ,					)

        return config, pixel_values, labels




 def 	__snake_case		(    self      :						str    ,					lowercase__      :						Dict    ,					lowercase__      :						int    ,					lowercase__      :						Optional[Any]):







        '''simple docstring'''



        lowerCAmelCase__  			=      PoolFormerModel(config=lowercase__)
        model.to(lowercase__)
        model.eval()
        lowerCAmelCase__  			=      model(lowercase__)
        lowerCAmelCase__  			=      lowerCAmelCase__  			=      self.image_size // 32.0
        self.parent.assertEqual(
            result.last_hidden_state.shape    ,					(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width))




 def 	__snake_case		(    self      :						Optional[int]):







        '''simple docstring'''



        lowerCAmelCase__  			=      self.prepare_config_and_inputs()
        lowerCAmelCase__			,      lowerCAmelCase__			,      lowerCAmelCase__  			=      config_and_inputs
        lowerCAmelCase__  			=      {'pixel_values': pixel_values}
        return config, inputs_dict






@require_torch
class        a_				(		SCREAMING_SNAKE_CASE ,  SCREAMING_SNAKE_CASE ,  unittest.TestCase		):






 '''simple docstring'''






 UpperCAmelCase_							=      (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
 UpperCAmelCase_							=      (
     {'feature-extraction': PoolFormerModel, 'image-classification': PoolFormerForImageClassification}
     if is_torch_available()
     else {}
 )

 UpperCAmelCase_							=      False
 UpperCAmelCase_							=      False
 UpperCAmelCase_							=      False
 UpperCAmelCase_							=      False
 UpperCAmelCase_							=      False




 def 	__snake_case		(    self      :						Dict):







        '''simple docstring'''



        lowerCAmelCase__  			=      PoolFormerModelTester(self)
        lowerCAmelCase__  			=      PoolFormerConfigTester(self    ,					config_class=lowercase__)




 def 	__snake_case		(    self      :						List[Any]):







        '''simple docstring'''



        self.config_tester.run_common_tests()




 def 	__snake_case		(    self      :						Optional[Any]):







        '''simple docstring'''



        lowerCAmelCase__  			=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase__)




 @unittest.skip('PoolFormer does not use inputs_embeds')
 def 	__snake_case		(    self      :						int):







        '''simple docstring'''



        pass




 @unittest.skip('PoolFormer does not have get_input_embeddings method and get_output_embeddings methods')
 def 	__snake_case		(    self      :						List[Any]):







        '''simple docstring'''



        pass




 def 	__snake_case		(    self      :						List[Any]):







        '''simple docstring'''



        def check_hidden_states_output(lowercase__      :						Any    ,					lowercase__      :						str    ,					lowercase__      :						Optional[int]):
               lowerCAmelCase__  			=      model_class(lowercase__)
               model.to(lowercase__)
               model.eval()

               with torch.no_grad():
                      lowerCAmelCase__  			=      model(**self._prepare_for_class(lowercase__    ,					lowercase__))

               lowerCAmelCase__  			=      outputs.hidden_states

               lowerCAmelCase__  			=      self.model_tester.num_encoder_blocks
               self.assertEqual(len(lowercase__)    ,					lowercase__)

               # verify the first hidden states (first block)
               self.assertListEqual(
                   list(hidden_states[0].shape[-3:])    ,					[
                       self.model_tester.hidden_sizes[0],
                       self.model_tester.image_size // 4,
                       self.model_tester.image_size // 4,
                   ]    ,					)

        lowerCAmelCase__			,      lowerCAmelCase__  			=      self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               lowerCAmelCase__  			=      True
               check_hidden_states_output(lowercase__    ,					lowercase__    ,					lowercase__)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               lowerCAmelCase__  			=      True

               check_hidden_states_output(lowercase__    ,					lowercase__    ,					lowercase__)




 def 	__snake_case		(    self      :						int):







        '''simple docstring'''



        if not self.model_tester.is_training:
               return

        lowerCAmelCase__			,      lowerCAmelCase__  			=      self.model_tester.prepare_config_and_inputs_for_common()
        lowerCAmelCase__  			=      True

        for model_class in self.all_model_classes:
               if model_class in get_values(lowercase__):
                      continue
               lowerCAmelCase__  			=      model_class(lowercase__)
               model.to(lowercase__)
               model.train()
               lowerCAmelCase__  			=      self._prepare_for_class(lowercase__    ,					lowercase__    ,					return_labels=lowercase__)
               lowerCAmelCase__  			=      model(**lowercase__).loss
               loss.backward()




 def 	__snake_case		(    self      :						Optional[Any]):







        '''simple docstring'''



        lowerCAmelCase__			,      lowerCAmelCase__  			=      self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               lowerCAmelCase__  			=      model_class(lowercase__)
               lowerCAmelCase__  			=      inspect.signature(model.forward)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               lowerCAmelCase__  			=      [*signature.parameters.keys()]

               lowerCAmelCase__  			=      ['pixel_values']
               self.assertListEqual(arg_names[:1]    ,					lowercase__)




 @slow
 def 	__snake_case		(    self      :						List[str]):







        '''simple docstring'''



        for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowerCAmelCase__  			=      PoolFormerModel.from_pretrained(lowercase__)
               self.assertIsNotNone(lowercase__)






def    __lowerCamelCase	(		):
       lowerCAmelCase__  			=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
       return image



@require_torch
class        a_				(		unittest.TestCase		):






 '''simple docstring'''






 @slow
 def 	__snake_case		(    self      :						Union[str, Any]):







        '''simple docstring'''



        lowerCAmelCase__  			=      PoolFormerImageProcessor()
        lowerCAmelCase__  			=      PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12').to(lowercase__)

        lowerCAmelCase__  			=      image_processor(images=prepare_img()    ,					return_tensors='pt').to(lowercase__)

        # forward pass
        with torch.no_grad():
               lowerCAmelCase__  			=      model(**lowercase__)

        # verify the logits
        lowerCAmelCase__  			=      torch.Size((1, 1_000))
        self.assertEqual(outputs.logits.shape    ,					lowercase__)

        lowerCAmelCase__  			=      torch.tensor([-0.6_113, 0.1_685, -0.0_492]).to(lowercase__)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,					lowercase__    ,					atol=1e-4))

from __future__ import annotations






def    __lowerCamelCase	(		lowerCAmelCase__			):
       global graph, reversed_graph, scc, component, visit, stack
       if visit[u]:
              return
       lowerCAmelCase__  			=      True
       for v in graph[u]:
              dfs(lowerCAmelCase__			)
       stack.append(lowerCAmelCase__			)






def    __lowerCamelCase	(		lowerCAmelCase__			):
       global graph, reversed_graph, scc, component, visit, stack
       if visit[u]:
              return
       lowerCAmelCase__  			=      True
       component.append(lowerCAmelCase__			)
       for v in reversed_graph[u]:
              dfsa(lowerCAmelCase__			)






def    __lowerCamelCase	(		):
       global graph, reversed_graph, scc, component, visit, stack
       for i in range(lowerCAmelCase__			):
              dfs(lowerCAmelCase__			)
       lowerCAmelCase__  			=      [False] * n
       for i in stack[::-1]:
              if visit[i]:
                     continue
              lowerCAmelCase__  			=      []
              dfsa(lowerCAmelCase__			)
              scc.append(lowerCAmelCase__			)
       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())
