



lowerCamelCase__     =	float("""inf""")






class 				SCREAMING_SNAKE_CASE     :





							def __init__(				self						:						Dict ,			__lowercase						:						Optional[Any]		):

											'''simple docstring'''
											__a					       =						[0] * n
											__a					       =						[0] * n
											__a					       =						[0] * n
											__a					       =						[[] for _ in range(__lowercase		)]





							def   UpperCamelCase_   (				self						:						Optional[Any] ,			__lowercase						:						Optional[int] ,			__lowercase						:						Dict ,			__lowercase						:						int ,			__lowercase						:						List[str]=0		):

											'''simple docstring'''
											self.adj[a].append([b, len(self.adj[b]		), c, 0]		)
											self.adj[b].append([a, len(self.adj[a]		) - 1, rcap, 0]		)





							def   UpperCamelCase_   (				self						:						int ,			__lowercase						:						Tuple ,			__lowercase						:						Tuple ,			__lowercase						:						Union[str, Any]		):

											'''simple docstring'''
											if vertex == sink or not flow:
															return flow

											for i in range(self.ptr[vertex] ,			len(self.adj[vertex]		)		):
															__a					       =						self.adj[vertex][i]
															if self.lvl[e[0]] == self.lvl[vertex] + 1:
																			__a					       =						self.depth_first_search(e[0] ,			__lowercase ,			min(__lowercase ,			e[2] - e[3]		)		)
																			if p:
																							self.adj[vertex][i][3] += p
																							self.adj[e[0]][e[1]][3] -= p
																							return p
															__a					       =						self.ptr[vertex] + 1
											return 0







							def   UpperCamelCase_   (				self						:						str ,			__lowercase						:						Union[str, Any] ,			__lowercase						:						str		):

											'''simple docstring'''
											__a       ,   __a					       =						0, source
											for l in range(31		):  # noqa: E741  l = 30 maybe faster for random data
															while True:
																			__a       ,   __a					       =						[0] * len(self.q		), [0] * len(self.q		)
																			__a       ,   __a       ,   __a					       =						0, 1, 1
																			while qi < qe and not self.lvl[sink]:
																							__a					       =						self.q[qi]
																							qi += 1
																							for e in self.adj[v]:
																											if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
																															__a					       =						e[0]
																															qe += 1
																															__a					       =						self.lvl[v] + 1

																			__a					       =						self.depth_first_search(__lowercase ,			__lowercase ,			__lowercase		)
																			while p:
																							flow += p
																							__a					       =						self.depth_first_search(__lowercase ,			__lowercase ,			__lowercase		)

																			if not self.lvl[sink]:
																							break

											return flow
lowerCamelCase__     =	Dinic(10)
lowerCamelCase__     =	0
lowerCamelCase__     =	9
for vertex in range(1, 5):
						graph.add_edge(source, vertex, 1)
for vertex in range(5, 9):
						graph.add_edge(vertex, sink, 1)
for vertex in range(1, 5):
						graph.add_edge(vertex, vertex + 4, 1)

# Now we can know that is the maximum flow(source -> sink)
print(graph.max_flow(source, sink))





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase__     =	logging.get_logger(__name__)

lowerCamelCase__     =	{
    """facebook/sam-vit-huge""": """https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json""",
    """facebook/sam-vit-large""": """https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json""",
    """facebook/sam-vit-base""": """https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json""",
}






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						List[Any] ,			__lowercase						:						Optional[Any]=256 ,			__lowercase						:						Optional[int]=1024 ,			__lowercase						:						Any=16 ,			__lowercase						:						Optional[Any]=16 ,			__lowercase						:						Optional[Any]=4 ,			__lowercase						:						Optional[int]="gelu" ,			__lowercase						:						List[Any]=1E-6 ,			**__lowercase						:						str ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						hidden_size
											__a					       =						image_size
											__a					       =						patch_size
											__a					       =						image_size // patch_size
											__a					       =						mask_input_channels
											__a					       =						num_point_embeddings
											__a					       =						hidden_act
											__a					       =						layer_norm_eps






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						int ,			__lowercase						:						Tuple=256 ,			__lowercase						:						List[Any]="relu" ,			__lowercase						:						Any=2048 ,			__lowercase						:						List[Any]=2 ,			__lowercase						:						List[str]=8 ,			__lowercase						:						Any=2 ,			__lowercase						:						List[Any]=3 ,			__lowercase						:						str=3 ,			__lowercase						:						str=256 ,			__lowercase						:						Optional[Any]=1E-6 ,			**__lowercase						:						Tuple ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						hidden_size
											__a					       =						hidden_act
											__a					       =						mlp_dim
											__a					       =						num_hidden_layers
											__a					       =						num_attention_heads
											__a					       =						attention_downsample_rate
											__a					       =						num_multimask_outputs
											__a					       =						iou_head_depth
											__a					       =						iou_head_hidden_dim
											__a					       =						layer_norm_eps






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):





							def __init__(				self						:						List[Any] ,			__lowercase						:						List[Any]=768 ,			__lowercase						:						List[Any]=256 ,			__lowercase						:						Any=12 ,			__lowercase						:						Tuple=12 ,			__lowercase						:						Union[str, Any]=3 ,			__lowercase						:						Tuple=1024 ,			__lowercase						:						Any=16 ,			__lowercase						:						Dict="gelu" ,			__lowercase						:						List[Any]=1E-06 ,			__lowercase						:						List[str]=0.0 ,			__lowercase						:						Optional[Any]=1E-10 ,			__lowercase						:						Optional[Any]=True ,			__lowercase						:						str=4.0 ,			__lowercase						:						List[Any]=True ,			__lowercase						:						Dict=True ,			__lowercase						:						Optional[Any]=14 ,			__lowercase						:						Optional[int]=[2, 5, 8, 11] ,			__lowercase						:						List[str]=128 ,			__lowercase						:						Optional[int]=None ,			**__lowercase						:						List[Any] ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)

											__a					       =						hidden_size
											__a					       =						output_channels
											__a					       =						num_hidden_layers
											__a					       =						num_attention_heads
											__a					       =						num_channels
											__a					       =						image_size
											__a					       =						patch_size
											__a					       =						hidden_act
											__a					       =						layer_norm_eps
											__a					       =						attention_dropout
											__a					       =						initializer_range
											__a					       =						qkv_bias
											__a					       =						mlp_ratio
											__a					       =						use_abs_pos
											__a					       =						use_rel_pos
											__a					       =						window_size
											__a					       =						global_attn_indexes
											__a					       =						num_pos_feats
											__a					       =						int(hidden_size * mlp_ratio		) if mlp_dim is None else mlp_dim






class 				SCREAMING_SNAKE_CASE     (							lowerCamelCase__   ):
							__lowerCamelCase		:		Dict      ='sam'
							__lowerCamelCase		:		Any      =True





							def __init__(				self						:						List[str] ,			__lowercase						:						List[str]=None ,			__lowercase						:						Optional[int]=None ,			__lowercase						:						Dict=None ,			__lowercase						:						Optional[int]=0.02 ,			**__lowercase						:						List[str] ,			):

											'''simple docstring'''
											super().__init__(**__lowercase		)
											__a					       =						vision_config if vision_config is not None else {}
											__a					       =						prompt_encoder_config if prompt_encoder_config is not None else {}
											__a					       =						mask_decoder_config if mask_decoder_config is not None else {}

											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						vision_config.to_dict()
											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						prompt_encoder_config.to_dict()
											if isinstance(__lowercase ,			__lowercase		):
															__a					       =						mask_decoder_config.to_dict()

											__a					       =						SamVisionConfig(**__lowercase		)
											__a					       =						SamPromptEncoderConfig(**__lowercase		)
											__a					       =						SamMaskDecoderConfig(**__lowercase		)
											__a					       =						initializer_range







							def   UpperCamelCase_   (				self						:						Union[str, Any]		):

											'''simple docstring'''
											__a					       =						copy.deepcopy(self.__dict__		)
											__a					       =						self.vision_config.to_dict()
											__a					       =						self.prompt_encoder_config.to_dict()
											__a					       =						self.mask_decoder_config.to_dict()
											__a					       =						self.__class__.model_type
											return output
