


'''simple docstring'''






def      UpperCAmelCase      (		lowerCamelCase_  :int ):







		'''simple docstring'''
		return str(lowerCamelCase_ ) == str(lowerCamelCase_ )[::-1]





def      UpperCAmelCase      (		lowerCamelCase_  :int ):







		'''simple docstring'''
		return int(lowerCamelCase_ ) + int(str(lowerCamelCase_ )[::-1] )





def      UpperCAmelCase      (		lowerCamelCase_  :int = 1_00_00 ):







		'''simple docstring'''
		snake_case_		:							Optional[Any]			       =						[]
		for num in range(1				,      lowerCamelCase_ ):
				snake_case_		:							Optional[int]			       =						0
				snake_case_		:							str			       =						num
				while iterations < 50:
						snake_case_		:							Optional[Any]			       =						sum_reverse(lowerCamelCase_ )
						iterations += 1
						if is_palindrome(lowerCamelCase_ ):
								break
				else:
						lychrel_nums.append(lowerCamelCase_ )
		return len(lowerCamelCase_ )


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



'''simple docstring'''






def      UpperCAmelCase      (		lowerCamelCase_  :Tuple				,      lowerCamelCase_  :Optional[Any]				,      lowerCamelCase_  :str				,      lowerCamelCase_  :str ):







		'''simple docstring'''
		# Return True if there is node that has not iterated.
		snake_case_		:							Optional[int]			       =						[False] * len(lowerCamelCase_ )
		snake_case_		:							Dict			       =						[]
		queue.append(lowerCamelCase_ )
		snake_case_		:							Tuple			       =						True

		while queue:
				snake_case_		:							Union[str, Any]			       =						queue.pop(0 )
				for ind in range(len(graph[u] ) ):
						if visited[ind] is False and graph[u][ind] > 0:
								queue.append(lowerCamelCase_ )
								snake_case_		:							str			       =						True
								snake_case_		:							Optional[Any]			       =						u

		return visited[t]





def      UpperCAmelCase      (		lowerCamelCase_  :Optional[Any]				,      lowerCamelCase_  :Dict				,      lowerCamelCase_  :Union[str, Any] ):







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

				while s != source:
						# Find the minimum value in select path
						snake_case_		:							Optional[Any]			       =						min(lowerCamelCase_				,      graph[parent[s]][s] )
						snake_case_		:							Union[str, Any]			       =						parent[s]

				max_flow += path_flow
				snake_case_		:							Dict			       =						sink

				while v != source:
						snake_case_		:							Optional[int]			       =						parent[v]
						graph[u][v] -= path_flow
						graph[v][u] += path_flow
						snake_case_		:							Any			       =						parent[v]
		return max_flow


__A	:	Union[str, Any]     =     [
    [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],
]

__A,   __A	:	Union[str, Any]     =     0, 5






print(ford_fulkerson(graph, source, sink))