


__magic_name__  	=     [
    [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],
]







def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_     ,	lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Tuple              =  [False] * len(_lowercase)
	lowerCamelCase_					:				List[str]              =  [s]
	lowerCamelCase_					:				Tuple              =  True

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

	return visited[t]







def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				int              =  [-1] * (len(_lowercase))
	lowerCamelCase_					:				Any              =  0
	lowerCamelCase_					:				List[Any]              =  []
	lowerCamelCase_					:				Any              =  [i[:] for i in graph]  # Record original cut, copy.
	while bfs(_lowercase     ,	_lowercase     ,	_lowercase     ,	_lowercase):
		lowerCamelCase_					:				List[str]              =  float("Inf")
		lowerCamelCase_					:				Tuple              =  sink

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

		max_flow += path_flow
		lowerCamelCase_					:				Optional[int]              =  sink

		while v != source:
			lowerCamelCase_					:				str              =  parent[v]
			graph[u][v] -= path_flow
			graph[v][u] += path_flow
			lowerCamelCase_					:				Optional[int]              =  parent[v]

	for i in range(len(_lowercase)):
		for j in range(len(graph[0])):
			if graph[i][j] == 0 and temp[i][j] > 0:
				res.append((i, j))

	return res


if __name__ == "__main__":
							print(mincut(test_graph, source=0, sink=5))





"""simple docstring"""



import math
from datetime import datetime, timedelta
def      UpperCAmelCase     (       _lowercase :   int	)						-> datetime:


	"""simple docstring"""




	lowerCAmelCase_      							=			year % 1_9
	lowerCAmelCase_      							=			year % 4
	lowerCAmelCase_      							=			year % 7
	lowerCAmelCase_      							=			math.floor(year / 1_0_0	)
	lowerCAmelCase_      							=			math.floor((1_3 + 8 * leap_day_inhibits) / 2_5	)
	lowerCAmelCase_      							=			leap_day_inhibits / 4
	lowerCAmelCase_      							=			(
	    1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 3_0
	lowerCAmelCase_      							=			(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

	# days to be added to March 21
	lowerCAmelCase_      							=			(1_9 * metonic_cycle + secular_moon_shift) % 3_0

	# PHM -> Paschal Full Moon
	lowerCAmelCase_      							=			(
	    2 * julian_leap_year
	    + 4 * non_leap_year
	    + 6 * days_to_add
	    + century_starting_point
	) % 7

	if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
		return datetime(_lowercase			,   4			,   1_9	)
	elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
		return datetime(_lowercase			,   4			,   1_8	)
	else:
		return datetime(_lowercase			,   3			,   2_2	) + timedelta(
		    days=int(days_to_add + days_from_phm_to_sunday	)	)


if __name__ == "__main__":
		for year in (19_94, 20_00, 20_10, 20_21, 20_23):
				lowercase_							=							'will be' if year > datetime.now().year else 'was'
				print(f"""Easter in {year} {tense} {gauss_easter(year)}""")