


'''simple docstring'''
def 					lowerCamelCase_ ( __UpperCamelCase					:       Tuple							,    __UpperCamelCase					:       Any							,    __UpperCamelCase					:       int							,    __UpperCamelCase					:       List[Any]		)					->	Tuple:







     """simple docstring"""
     # Return True if there is node that has not iterated.
     _A				=							[False] * len(__UpperCamelCase		)
     _A				=							[]
     queue.append(__UpperCamelCase		)
     _A				=							True

     while queue:
          _A				=							queue.pop(0		)
          for ind in range(len(graph[u]		)		):
               if visited[ind] is False and graph[u][ind] > 0:
                    queue.append(__UpperCamelCase		)
                    _A				=							True
                    _A				=							u

     return visited[t]

def 					lowerCamelCase_ ( __UpperCamelCase					:       Union[str, Any]							,    __UpperCamelCase					:       Tuple							,    __UpperCamelCase					:       Tuple		)					->	Tuple:







     """simple docstring"""
     # This array is filled by BFS and to store path
     _A				=							[-1] * (len(__UpperCamelCase		))
     _A				=							0
     while bfs(__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase		):
          _A				=							float('Inf'		)
          _A				=							sink

          while s != source:
               # Find the minimum value in select path
               _A				=							min(__UpperCamelCase							,    graph[parent[s]][s]		)
               _A				=							parent[s]

          max_flow += path_flow
          _A				=							sink

          while v != source:
               _A				=							parent[v]
               graph[u][v] -= path_flow
               graph[v][u] += path_flow
               _A				=							parent[v]
     return max_flow


lowerCAmelCase						=					[
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

lowerCAmelCase			,lowerCAmelCase						=					0, 5
print(ford_fulkerson(graph, source, sink))









'''simple docstring'''
def 					lowerCamelCase_ ( __UpperCamelCase					:       int		)					->	bool:







     """simple docstring"""
     return str(__UpperCamelCase		) == str(__UpperCamelCase		)[::-1]

def 					lowerCamelCase_ ( __UpperCamelCase					:       int		)					->	int:







     """simple docstring"""
     return int(__UpperCamelCase		) + int(str(__UpperCamelCase		)[::-1]		)

def 					lowerCamelCase_ ( __UpperCamelCase					:       int = 1_0_0_0_0		)					->	int:







     """simple docstring"""
     _A				=							[]
     for num in range(1							,    __UpperCamelCase		):
          _A				=							0
          _A				=							num
          while iterations < 5_0:
               _A				=							sum_reverse(__UpperCamelCase		)
               iterations += 1
               if is_palindrome(__UpperCamelCase		):
                    break
          else:
               lychrel_nums.append(__UpperCamelCase		)
     return len(__UpperCamelCase		)


if __name__ == "__main__":
    print(F'{solution() = }')





