





__A    :   Any          =       float("inf")

class      A_	:
 def __init__(   self							, _A		):






    '''simple docstring'''







    UpperCAmelCase       		=    [0] * n
    UpperCAmelCase       		=    [0] * n
    UpperCAmelCase       		=    [0] * n
    UpperCAmelCase       		=    [[] for _ in range(_A		)]
 def 					_lowercase    (   self							, _A							, _A							, _A							, _A=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 					_lowercase    (   self							, _A							, _A							, _A		):






    '''simple docstring'''







    if vertex == sink or not flow:
       return flow

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







 def 					_lowercase    (   self							, _A							, _A		):






    '''simple docstring'''







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

          UpperCAmelCase       		=    self.depth_first_search(_A							, _A							, _A		)
          while p:
             flow += p
             UpperCAmelCase       		=    self.depth_first_search(_A							, _A							, _A		)

          if not self.lvl[sink]:
             break

    return flow
__A    :   Tuple          =       Dinic(10)
__A    :   str          =       0
__A    :   int          =       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
from ..auto.configuration_auto import AutoConfig


__A    :   Optional[int]          =       logging.get_logger(__name__)

class      A_	(a_      ):
	UpperCAmelCase__ =      '''speech-encoder-decoder'''
	UpperCAmelCase__ =      True
	def __init__(   self							, **_A		):






				'''simple docstring'''







				super().__init__(**_A		)
				if "encoder" not in kwargs or "decoder" not in kwargs:
							raise ValueError(
							    F"""A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and"""
							    F""" `decoder` sub-configurations are passed, but only {kwargs}"""		)

				UpperCAmelCase       		=    kwargs.pop('''encoder'''		)
				UpperCAmelCase       		=    encoder_config.pop('''model_type'''		)
				UpperCAmelCase       		=    kwargs.pop('''decoder'''		)
				UpperCAmelCase       		=    decoder_config.pop('''model_type'''		)

				UpperCAmelCase       		=    AutoConfig.for_model(_A							, **_A		)
				UpperCAmelCase       		=    AutoConfig.for_model(_A							, **_A		)
				UpperCAmelCase       		=    True
	@classmethod
	def 					_lowercase    (   cls							, _A							, _A							, **_A		):






				'''simple docstring'''







				logger.info('''Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''		)
				UpperCAmelCase       		=    True
				UpperCAmelCase       		=    True

				return cls(encoder=encoder_config.to_dict()							, decoder=decoder_config.to_dict()							, **_A		)







	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    copy.deepcopy(self.__dict__		)
				UpperCAmelCase       		=    self.encoder.to_dict()
				UpperCAmelCase       		=    self.decoder.to_dict()
				UpperCAmelCase       		=    self.__class__.model_type
				return output



