






'''simple docstring'''







from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_A			:    Dict					  =logging.get_logger(__name__)

_A			:    Dict					  ={
    '''facebook/convnextv2-tiny-1k-224''': '''https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json''',
}

class _lowercase			(       _lowercase       ,   _lowercase	):
       a          = """convnextv2"""




       def __init__(							self:       List[Any]    ,							UpperCamelCase__:       Optional[int]=3    ,							UpperCamelCase__:       Any=4    ,							UpperCamelCase__:       int=4    ,							UpperCamelCase__:       Optional[Any]=None    ,							UpperCamelCase__:       Optional[Any]=None    ,							UpperCamelCase__:       int="gelu"    ,							UpperCamelCase__:       Union[str, Any]=0.02    ,							UpperCamelCase__:       Optional[Any]=1e-12    ,							UpperCamelCase__:       Tuple=0.0    ,							UpperCamelCase__:       List[str]=224    ,							UpperCamelCase__:       Dict=None    ,							UpperCamelCase__:       List[Any]=None    ,							**UpperCamelCase__:       Any    ,							):
              super().__init__(**UpperCamelCase__  )

              lowerCamelCase__      :			List[str] 						= num_channels
              lowerCamelCase__      :			Optional[int] 						= patch_size
              lowerCamelCase__      :			List[Any] 						= num_stages
              lowerCamelCase__      :			Any 						= [96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
              lowerCamelCase__      :			List[Any] 						= [3, 3, 9, 3] if depths is None else depths
              lowerCamelCase__      :			Any 						= hidden_act
              lowerCamelCase__      :			List[Any] 						= initializer_range
              lowerCamelCase__      :			int 						= layer_norm_eps
              lowerCamelCase__      :			Dict 						= drop_path_rate
              lowerCamelCase__      :			Dict 						= image_size
              lowerCamelCase__      :			Union[str, Any] 						= ["""stem"""] + [F'''stage{idx}''' for idx in range(1    ,							len(self.depths  ) + 1  )]
              lowerCamelCase__      :			Optional[Any] 						= get_aligned_output_features_output_indices(
                  out_features=UpperCamelCase__    ,							out_indices=UpperCamelCase__    ,							stage_names=self.stage_names  )









'''simple docstring'''







# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
# or u belongs to V and v to U. We can also say that there is no edge that connects
# vertices of same set.





def 				SCREAMING_SNAKE_CASE_ (UpperCamelCase   )   -> Optional[Any]:
							lowerCamelCase__      :			str 						= [False] * len(UpperCamelCase   )
							lowerCamelCase__      :			str 						= [-1] * len(UpperCamelCase   )

							def dfs(UpperCamelCase       ,    UpperCamelCase   ):
														lowerCamelCase__      :			Optional[int] 						= True
														lowerCamelCase__      :			Union[str, Any] 						= c
														for u in graph[v]:
																					if not visited[u]:
																												dfs(UpperCamelCase       ,    1 - c   )

							for i in range(len(UpperCamelCase   )   ):
														if not visited[i]:
																					dfs(UpperCamelCase       ,    0   )

							for i in range(len(UpperCamelCase   )   ):
														for j in graph[i]:
																					if color[i] == color[j]:
																												return False

							return True


# Adjacency list of graph
_A			:    int					  ={0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}



print(check_bipartite_dfs(graph))

