





import math





def      lowerCAmelCase_ (       __a		)     ->		bool:







  """simple docstring"""





  lowerCamelCase__:      Any			  =math.loga(math.sqrt(4 * positive_integer + 1		) / 2 + 1 / 2		)

  return exponent == int(__a		)





def      lowerCAmelCase_ (       __a = 1 / 12345		)     ->		int:







  """simple docstring"""





  lowerCamelCase__:      Union[str, Any]			  =0
  lowerCamelCase__:      List[Any]			  =0

  lowerCamelCase__:      str			  =3
  while True:
    lowerCamelCase__:      Optional[int]			  =(integer**2 - 1) / 4
    # if candidate is an integer, then there is a partition for k
    if partition_candidate == int(__a		):
      lowerCamelCase__:      List[Any]			  =int(__a		)
      total_partitions += 1
      if check_partition_perfect(__a		):
        perfect_partitions += 1
    if perfect_partitions > 0:
      if perfect_partitions / total_partitions < max_proportion:
        return int(__a		)
    integer += 1


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





def        _lowerCamelCase(	lowercase__   , lowercase__   , lowercase__   , lowercase__	)						->	Union[str, Any]:

		'''simple docstring'''







		__lowercase=			[False] * len(lowercase__	)
		__lowercase=			[]
		queue.append(lowercase__	)
		__lowercase=			True

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

		return visited[t]







def        _lowerCamelCase(	lowercase__   , lowercase__   , lowercase__	)						->	int:

		'''simple docstring'''







		__lowercase=			[-1] * (len(lowercase__	))
		__lowercase=			0
		while bfs(lowercase__   , lowercase__   , lowercase__   , lowercase__	):
				__lowercase=			float('Inf'	)
				__lowercase=			sink

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

				max_flow += path_flow
				__lowercase=			sink

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


lowerCAmelCase           =		[
    [0, 1_6, 1_3, 0, 0, 0],
    [0, 0, 1_0, 1_2, 0, 0],
    [0, 4, 0, 0, 1_4, 0],
    [0, 0, 9, 0, 0, 2_0],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

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






