



'''simple docstring'''

from __future__ import annotations






def 						_snake_case						(   _SCREAMING_SNAKE_CASE	:		list[list[int]]				)     ->		int:







	"""simple docstring"""

	# preprocessing the first row
	for i in range(1				,						len(matrix[0]				)				):
		matrix[0][i] += matrix[0][i - 1]

	# preprocessing the first column
	for i in range(1				,						len(a__				)				):
		matrix[i][0] += matrix[i - 1][0]

	# updating the path cost for current position
	for i in range(1				,						len(a__				)				):
		for j in range(1				,						len(matrix[0]				)				):
			matrix[i][j] += min(matrix[i - 1][j]				,						matrix[i][j - 1]				)

	return matrix[-1][-1]


if __name__ == "__main__":
				import doctest

				doctest.testmod()


UpperCAmelCase_							:					dict[tuple[int, int, int], int]		 =   {}
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int			,a__    :   int			,a__    :   int       )					->				int:

	# 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
	__A :			List[Any]		    =			(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
	__A :			Dict		    =			_calculate(days - 1			,a__			,late + 1       )

	# 2) if we are absent, the "absent" counter increases by 1, and the
	# "late" counter resets to 0
	__A :			List[str]		    =			_calculate(days - 1			,absent + 1			,0       )

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

	__A :			Optional[int]		    =			state_late + state_absent + state_ontime

	__A :			Tuple		    =			prizestrings
	return prizestrings
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int = 30       )					->				int:
	return _calculate(a__			,absent=0			,late=0       )


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





