_a:    dict[tuple[int, int, int], int] 							=			{}



def       __lowerCAmelCase      (						A       ,     A       ,     A    ):

	# if we are absent twice, or late 3 consecutive days,
	# no further prize strings are possible
	if late == 3 or absent == 2:
		return 0

	# if we have no days left, and have not failed any other rules,
	# we have a prize string
	if days == 0:
		return 1

	# No easy solution, so now we need to do the recursive calculation

	# First, check if the combination is already in the cache, and
	# if yes, return the stored value from there since we already
	# know the number of possible prize strings from this point on
	UpperCAmelCase_       				=			(days, absent, late)
	if key in cache:
		return cache[key]

	# now we calculate the three possible ways that can unfold from
	# this point on, depending on our attendance today

	# 1) if we are late (but not absent), the "absent" counter stays as
	# it is, but the "late" counter increases by one
	UpperCAmelCase_       				=			_calculate(days - 1       ,     A       ,     late + 1    )

	# 2) if we are absent, the "absent" counter increases by 1, and the
	# "late" counter resets to 0
	UpperCAmelCase_       				=			_calculate(days - 1       ,     absent + 1       ,     0    )

	# 3) if we are on time, this resets the "late" counter and keeps the
	# absent counter
	UpperCAmelCase_       				=			_calculate(days - 1       ,     A       ,     0    )

	UpperCAmelCase_       				=			state_late + state_absent + state_ontime

	UpperCAmelCase_       				=			prizestrings
	return prizestrings



def       __lowerCAmelCase      (						A = 30    ):
	return _calculate(A       ,     absent=0       ,     late=0    )


if __name__ == "__main__":
				print(solution())


from __future__ import annotations



def       __lowerCAmelCase      (						A       ,     A    ):
	print(F"Vertex\tShortest Distance from vertex {src}"    )
	for i, d in enumerate(A    ):
		print(F"{i}\t\t{d}"    )



def       __lowerCAmelCase      (						A       ,     A       ,     A    ):
	for j in range(A    ):
		UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_       				=			(graph[j][k] for k in ["src", "dst", "weight"])
		if distance[u] != float("inf"    ) and distance[u] + w < distance[v]:
			return True
	return False



def       __lowerCAmelCase      (						A       ,     A       ,     A       ,     A    ):
	UpperCAmelCase_       				=			[float("inf"    )] * vertex_count
	UpperCAmelCase_       				=			0.0

	for _ in range(vertex_count - 1    ):
		for j in range(A    ):
			UpperCAmelCase_				,   UpperCAmelCase_				,   UpperCAmelCase_       				=			(graph[j][k] for k in ["src", "dst", "weight"])

			if distance[u] != float("inf"    ) and distance[u] + w < distance[v]:
				UpperCAmelCase_       				=			distance[u] + w

	UpperCAmelCase_       				=			check_negative_cycle(A       ,     A       ,     A    )
	if negative_cycle_exists:
		raise Exception("Negative cycle found"    )

	return distance


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				_a:    List[str] 							=			int(input("""Enter number of vertices: """).strip())
				_a:    str 							=			int(input("""Enter number of edges: """).strip())

				_a:    list[dict[str, int]] 							=			[{} for _ in range(E)]

				for i in range(E):
								print("""Edge """, i + 1)
								_a							,			_a							,			_a:    Any 							=			(
								    int(x)
								    for x in input("""Enter source, destination, weight: """).strip().split(""" """)
								)
								_a:    str 							=			{"""src""": src, """dst""": dest, """weight""": weight}

				_a:    List[Any] 							=			int(input("""\nEnter shortest path source:""").strip())
				_a:    Optional[int] 							=			bellman_ford(graph, V, E, source)
				print_distance(shortest_distance, 0)