


import random
import unittest

import numpy as np
import torch
from PIL import Image
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class 	a__						(    _UpperCAmelCase    ,							unittest.TestCase     ):
       lowerCamelCase__:  Optional[int]				     =  KandinskyVaaPriorEmbaEmbPipeline
       lowerCamelCase__:  Union[str, Any]				     =  ["""prompt""", """image"""]
       lowerCamelCase__:  Optional[int]				     =  ["""prompt""", """image"""]
       lowerCamelCase__:  Dict				     =  [
           """num_images_per_prompt""",
           """strength""",
           """generator""",
           """num_inference_steps""",
           """latents""",
           """negative_prompt""",
           """guidance_scale""",
           """output_type""",
           """return_dict""",
       ]
       lowerCamelCase__:  int				     =  False

       @property
       def     UpperCAmelCase( self   :  Optional[int]     ):
            return 3_2

       @property
       def     UpperCAmelCase( self   :  int     ):
            return 3_2

       @property
       def     UpperCAmelCase( self   :  List[Any]     ):
            return self.time_input_dim

       @property
       def     UpperCAmelCase( self   :  str     ):
            return self.time_input_dim * 4

       @property
       def     UpperCAmelCase( self   :  Tuple     ):
            return 1_0_0

       @property
       def     UpperCAmelCase( self   :  Tuple     ):
            a_     :  str				      =     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )
            return tokenizer

       @property
       def     UpperCAmelCase( self   :  Optional[Any]     ):
            torch.manual_seed(0     )
            a_     :  List[str]				      =     CLIPTextConfig(
                bos_token_id=0   ,				eos_token_id=2   ,				hidden_size=self.text_embedder_hidden_size   ,				projection_dim=self.text_embedder_hidden_size   ,				intermediate_size=3_7   ,				layer_norm_eps=1E-05   ,				num_attention_heads=4   ,				num_hidden_layers=5   ,				pad_token_id=1   ,				vocab_size=1_0_0_0   ,				)
            return CLIPTextModelWithProjection(lowercase_     )

       @property
       def     UpperCAmelCase( self   :  List[Any]     ):
            torch.manual_seed(0     )

            a_     :  Optional[Any]				      =     {
                """num_attention_heads""": 2,
                """attention_head_dim""": 1_2,
                """embedding_dim""": self.text_embedder_hidden_size,
                """num_layers""": 1,
            }

            a_     :  List[str]				      =     PriorTransformer(**lowercase_     )
            # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
            a_     :  Optional[int]				      =     nn.Parameter(torch.ones(model.clip_std.shape     )     )
            return model

       @property
       def     UpperCAmelCase( self   :  Optional[Any]     ):
            torch.manual_seed(0     )
            a_     :  int				      =     CLIPVisionConfig(
                hidden_size=self.text_embedder_hidden_size   ,				image_size=2_2_4   ,				projection_dim=self.text_embedder_hidden_size   ,				intermediate_size=3_7   ,				num_attention_heads=4   ,				num_channels=3   ,				num_hidden_layers=5   ,				patch_size=1_4   ,				)

            a_     :  Union[str, Any]				      =     CLIPVisionModelWithProjection(lowercase_     )
            return model

       @property
       def     UpperCAmelCase( self   :  str     ):
            a_     :  Tuple				      =     CLIPImageProcessor(
                crop_size=2_2_4   ,				do_center_crop=lowercase_   ,				do_normalize=lowercase_   ,				do_resize=lowercase_   ,				image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]   ,				image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]   ,				resample=3   ,				size=2_2_4   ,				)

            return image_processor

       def     UpperCAmelCase( self   :  List[Any]     ):
            a_     :  int				      =     self.dummy_prior
            a_     :  Tuple				      =     self.dummy_image_encoder
            a_     :  Tuple				      =     self.dummy_text_encoder
            a_     :  Tuple				      =     self.dummy_tokenizer
            a_     :  Union[str, Any]				      =     self.dummy_image_processor

            a_     :  Optional[int]				      =     UnCLIPScheduler(
                variance_type="""fixed_small_log"""   ,				prediction_type="""sample"""   ,				num_train_timesteps=1_0_0_0   ,				clip_sample=lowercase_   ,				clip_sample_range=1_0.0   ,				)

            a_     :  Tuple				      =     {
                """prior""": prior,
                """image_encoder""": image_encoder,
                """text_encoder""": text_encoder,
                """tokenizer""": tokenizer,
                """scheduler""": scheduler,
                """image_processor""": image_processor,
            }

            return components

       def     UpperCAmelCase( self   :  int   ,				lowerCamelCase_   :  Union[str, Any]   ,				lowerCamelCase_   :  int=0     ):
            if str(lowercase_     ).startswith("""mps"""     ):
                 a_     :  int				      =     torch.manual_seed(lowercase_     )
            else:
                 a_     :  Tuple				      =     torch.Generator(device=lowercase_     ).manual_seed(lowercase_     )

            a_     :  Optional[Any]				      =     floats_tensor((1, 3, 6_4, 6_4)   ,				rng=random.Random(lowercase_     )     ).to(lowercase_     )
            a_     :  Any				      =     image.cpu().permute(0   ,				2   ,				3   ,				1     )[0]
            a_     :  str				      =     Image.fromarray(np.uinta(lowercase_     )     ).convert("""RGB"""     ).resize((2_5_6, 2_5_6)     )

            a_     :  str				      =     {
                """prompt""": """horse""",
                """image""": init_image,
                """strength""": 0.5,
                """generator""": generator,
                """guidance_scale""": 4.0,
                """num_inference_steps""": 2,
                """output_type""": """np""",
            }
            return inputs

       def     UpperCAmelCase( self   :  Any     ):
            a_     :  Optional[int]				      =     """cpu"""

            a_     :  List[str]				      =     self.get_dummy_components()

            a_     :  List[Any]				      =     self.pipeline_class(**lowercase_     )
            a_     :  Union[str, Any]				      =     pipe.to(lowercase_     )

            pipe.set_progress_bar_config(disable=lowercase_     )

            a_     :  Any				      =     pipe(**self.get_dummy_inputs(lowercase_     )     )
            a_     :  List[str]				      =     output.image_embeds

            a_     :  Tuple				      =     pipe(
                **self.get_dummy_inputs(lowercase_     )   ,				return_dict=lowercase_   ,				)[0]

            a_     :  List[Any]				      =     image[0, -1_0:]
            a_     :  Tuple				      =     image_from_tuple[0, -1_0:]

            assert image.shape == (1, 3_2)

            a_     :  Optional[Any]				      =     np.array(
                [
                    0.1_0_7_1_2_8_4,
                    1.3_3_3_0_2_7_1,
                    0.6_1_2_6_0_2_2_3,
                    -0.6_6_9_1_0_6_5,
                    -0.3_8_4_6_8_5_2,
                    -1.0_3_0_3_6_6_1,
                    0.2_2_7_1_6_1_1_1,
                    0.0_3_3_4_8_9_0_1,
                    0.3_0_0_4_0_6_7_5,
                    -0.2_4_8_0_5_0_2_9,
                ]     )

            assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2
            assert np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < 1E-2

       @skip_mps
       def     UpperCAmelCase( self   :  Union[str, Any]     ):
            a_     :  Any				      =     torch_device == """cpu"""
            a_     :  Optional[Any]				      =     True
            a_     :  Optional[int]				      =     False

            self._test_inference_batch_single_identical(
                test_max_difference=lowercase_   ,				relax_max_difference=lowercase_   ,				test_mean_pixel_difference=lowercase_   ,				)

       @skip_mps
       def     UpperCAmelCase( self   :  int     ):
            a_     :  int				      =     torch_device == """cpu"""
            a_     :  Optional[int]				      =     False

            self._test_attention_slicing_forward_pass(
                test_max_difference=lowercase_   ,				test_mean_pixel_difference=lowercase_   ,				)




'''simple docstring'''




from __future__ import annotations




def 				lowerCamelCase      ( UpperCAmelCase__			:   str					)     -> Any:
							global graph, reversed_graph, scc, component, visit, stack
							if visit[u]:
														return
							lowercase_   :     int									=			True
							for v in graph[u]:
														dfs(UpperCAmelCase__					)
							stack.append(UpperCAmelCase__					)




def 				lowerCamelCase      ( UpperCAmelCase__			:   int					)     -> str:
							global graph, reversed_graph, scc, component, visit, stack
							if visit[u]:
														return
							lowercase_   :     Tuple									=			True
							component.append(UpperCAmelCase__					)
							for v in reversed_graph[u]:
														dfsa(UpperCAmelCase__					)




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


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

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

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





