


'''simple docstring'''
__snake_case											=					{0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

__snake_case											=					{0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}


def       a				(      __a			, __a			, __a       )  ->     list[int]:



					'''simple docstring'''






					UpperCamelCase__       :Union[str, Any]							 =			True
					UpperCamelCase__       :Tuple							 =			[]

					for neighbour in graph[vert]:
										if not visited[neighbour]:
															order += topology_sort(__a			, __a			, __a       )

					order.append(__a       )

					return order


def       a				(      __a			, __a			, __a       )  ->     list[int]:



					'''simple docstring'''






					UpperCamelCase__       :Tuple							 =			True
					UpperCamelCase__       :Union[str, Any]							 =			[vert]

					for neighbour in reversed_graph[vert]:
										if not visited[neighbour]:
															component += find_components(__a			, __a			, __a       )

					return component







def       a				(      __a       )  ->     list[list[int]]:



					'''simple docstring'''






					UpperCamelCase__       :List[str]							 =			len(__a       ) * [False]
					UpperCamelCase__       :dict[int, list[int]]							 =			{vert: [] for vert in range(len(__a       )       )}

					for vert, neighbours in graph.items():
										for neighbour in neighbours:
															reversed_graph[neighbour].append(__a       )

					UpperCamelCase__       :Optional[int]							 =			[]
					for i, was_visited in enumerate(__a       ):
										if not was_visited:
															order += topology_sort(__a			, __a			, __a       )

					UpperCamelCase__       :Tuple							 =			[]
					UpperCamelCase__       :str							 =			len(__a       ) * [False]

					for i in range(len(__a       )       ):
										UpperCamelCase__       :List[Any]							 =			order[len(__a       ) - i - 1]
										if not visited[vert]:
															UpperCamelCase__       :Optional[Any]							 =			find_components(__a			, __a			, __a       )
															components_list.append(__a       )

					return components_list



'''simple docstring'''
import logging

from transformers.configuration_utils import PretrainedConfig


__snake_case											=					logging.getLogger(__name__)
class        lowercase     (							A__ ):

		"""simple docstring"""

		_a   			=    'masked_bert'




		def __init__(		self   ,       UpperCamelCase_=30522   ,       UpperCamelCase_=768   ,       UpperCamelCase_=12   ,       UpperCamelCase_=12   ,       UpperCamelCase_=3072   ,       UpperCamelCase_="gelu"   ,       UpperCamelCase_=0.1   ,       UpperCamelCase_=0.1   ,       UpperCamelCase_=512   ,       UpperCamelCase_=2   ,       UpperCamelCase_=0.02   ,       UpperCamelCase_=1e-12   ,       UpperCamelCase_=0   ,       UpperCamelCase_="topK"   ,       UpperCamelCase_="constant"   ,       UpperCamelCase_=0.0   ,       **UpperCamelCase_   ,       ):

							'''simple docstring'''


							super().__init__(pad_token_id=UpperCamelCase_   ,       **UpperCamelCase_							)

							UpperCamelCase__       :Tuple							 =			vocab_size
							UpperCamelCase__       :Dict							 =			hidden_size
							UpperCamelCase__       :Optional[int]							 =			num_hidden_layers
							UpperCamelCase__       :Any							 =			num_attention_heads
							UpperCamelCase__       :Optional[Any]							 =			hidden_act
							UpperCamelCase__       :str							 =			intermediate_size
							UpperCamelCase__       :List[Any]							 =			hidden_dropout_prob
							UpperCamelCase__       :List[str]							 =			attention_probs_dropout_prob
							UpperCamelCase__       :List[Any]							 =			max_position_embeddings
							UpperCamelCase__       :int							 =			type_vocab_size
							UpperCamelCase__       :List[Any]							 =			initializer_range
							UpperCamelCase__       :Any							 =			layer_norm_eps
							UpperCamelCase__       :str							 =			pruning_method
							UpperCamelCase__       :int							 =			mask_init
							UpperCamelCase__       :Optional[Any]							 =			mask_scale