



'''simple docstring'''







import argparse
import json

import torch

from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel





def     snake_case__			(lowerCAmelCase_       ,	lowerCAmelCase_						):
    UpperCamelCase__	     =      UNetaDModel(**UpperCAmelCase__						)
    UpperCamelCase__	     =      checkpoint["""all_modules.0.W"""].data
    UpperCamelCase__	     =      checkpoint["""all_modules.0.W"""].data
    UpperCamelCase__	     =      checkpoint["""all_modules.1.weight"""].data
    UpperCamelCase__	     =      checkpoint["""all_modules.1.bias"""].data

    UpperCamelCase__	     =      checkpoint["""all_modules.2.weight"""].data
    UpperCamelCase__	     =      checkpoint["""all_modules.2.bias"""].data

    UpperCamelCase__	     =      checkpoint["""all_modules.3.weight"""].data
    UpperCamelCase__	     =      checkpoint["""all_modules.3.bias"""].data

    UpperCamelCase__	     =      checkpoint[list(checkpoint.keys()						)[-4]].data
    UpperCamelCase__	     =      checkpoint[list(checkpoint.keys()						)[-3]].data
    UpperCamelCase__	     =      checkpoint[list(checkpoint.keys()						)[-2]].data
    UpperCamelCase__	     =      checkpoint[list(checkpoint.keys()						)[-1]].data

    UpperCamelCase__	     =      4

    def set_attention_weights(lowerCAmelCase_       ,	lowerCAmelCase_       ,	lowerCAmelCase_						):
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_0.W'].data.T
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_1.W'].data.T
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_2.W'].data.T

        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_0.b'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_1.b'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_2.b'].data

        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_3.W'].data.T
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.NIN_3.b'].data

        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.GroupNorm_0.weight'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.GroupNorm_0.bias'].data

    def set_resnet_weights(lowerCAmelCase_       ,	lowerCAmelCase_       ,	lowerCAmelCase_						):
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Conv_0.weight'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Conv_0.bias'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.GroupNorm_0.weight'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.GroupNorm_0.bias'].data

        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Conv_1.weight'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Conv_1.bias'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.GroupNorm_1.weight'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.GroupNorm_1.bias'].data

        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Dense_0.weight'].data
        UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Dense_0.bias'].data

        if new_layer.in_channels != new_layer.out_channels or new_layer.up or new_layer.down:
            UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Conv_2.weight'].data
            UpperCamelCase__	     =      old_checkpoint[F'all_modules.{index}.Conv_2.bias'].data

    for i, block in enumerate(new_model_architecture.downsample_blocks						):
        UpperCamelCase__	     =      hasattr(UpperCAmelCase__       ,	"attentions"						)
        for j in range(len(block.resnets						)						):
            set_resnet_weights(block.resnets[j]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
            module_index += 1
            if has_attentions:
                set_attention_weights(block.attentions[j]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
                module_index += 1

        if hasattr(UpperCAmelCase__       ,	"downsamplers"						) and block.downsamplers is not None:
            set_resnet_weights(block.resnet_down       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
            module_index += 1
            UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.Conv_0.weight'].data
            UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.Conv_0.bias'].data
            module_index += 1

    set_resnet_weights(new_model_architecture.mid_block.resnets[0]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
    module_index += 1
    set_attention_weights(new_model_architecture.mid_block.attentions[0]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
    module_index += 1
    set_resnet_weights(new_model_architecture.mid_block.resnets[1]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
    module_index += 1

    for i, block in enumerate(new_model_architecture.up_blocks						):
        UpperCamelCase__	     =      hasattr(UpperCAmelCase__       ,	"attentions"						)
        for j in range(len(block.resnets						)						):
            set_resnet_weights(block.resnets[j]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
            module_index += 1
        if has_attentions:
            set_attention_weights(
                block.attentions[0]       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)  # why can there only be a single attention layer for up?
            module_index += 1

        if hasattr(UpperCAmelCase__       ,	"resnet_up"						) and block.resnet_up is not None:
            UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.weight'].data
            UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.bias'].data
            module_index += 1
            UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.weight'].data
            UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.bias'].data
            module_index += 1
            set_resnet_weights(block.resnet_up       ,	UpperCAmelCase__       ,	UpperCAmelCase__						)
            module_index += 1

    UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.weight'].data
    UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.bias'].data
    module_index += 1
    UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.weight'].data
    UpperCamelCase__	     =      checkpoint[F'all_modules.{module_index}.bias'].data

    return new_model_architecture.state_dict()


if __name__ == "__main__":
      lowercase__  :	Optional[int]            =      argparse.ArgumentParser()

      parser.add_argument(
          '--checkpoint_path',
          default='/Users/arthurzucker/Work/diffusers/ArthurZ/diffusion_pytorch_model.bin',
          type=str,
          required=False,
          help='Path to the checkpoint to convert.',
      )

      parser.add_argument(
          '--config_file',
          default='/Users/arthurzucker/Work/diffusers/ArthurZ/config.json',
          type=str,
          required=False,
          help='The config json file corresponding to the architecture.',
      )

      parser.add_argument(
          '--dump_path',
          default='/Users/arthurzucker/Work/diffusers/ArthurZ/diffusion_model_new.pt',
          type=str,
          required=False,
          help='Path to the output model.',
      )

      lowercase__  :	List[Any]            =      parser.parse_args()

      lowercase__  :	List[str]            =      torch.load(args.checkpoint_path, map_location='cpu')

      with open(args.config_file) as f:
            lowercase__  :	List[Any]            =      json.loads(f.read())

      lowercase__  :	Any            =      convert_ncsnpp_checkpoint(
          checkpoint,
          config,
      )

      if "sde" in config:
            del config["sde"]

      lowercase__  :	str            =      UNetaDModel(**config)
      model.load_state_dict(converted_checkpoint)

      try:
            lowercase__  :	Tuple            =      ScoreSdeVeScheduler.from_config('/'.join(args.checkpoint_path.split('/')[:-1]))

            lowercase__  :	Dict            =      ScoreSdeVePipeline(unet=model, scheduler=scheduler)
            pipe.save_pretrained(args.dump_path)
      except:  # noqa: E722
            model.save_pretrained(args.dump_path)





'''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())





