






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



def  a__ (__lowercase							:int					,  __lowercase							:int					,  __lowercase							: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	:				Union[str, 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	:				Any   =      _calculate(days - 1					,  __lowercase					,  late + 1   )

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

				# 3) if we are on time, this resets the "late" counter and keeps the
				# absent counter
				_A	:				Union[str, Any]   =      _calculate(days - 1					,  __lowercase					,  0   )

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

				_A	:				int   =      prizestrings
				return prizestrings



def  a__ (__lowercase							:int = 30   )		-> int:
				return _calculate(__lowercase					,  absent=0					,  late=0   )


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











from __future__ import annotations



def  a__ (__lowercase							:list					,  __lowercase							:int | None = None					,  __lowercase							:int | None = None   )		-> None:
				if start is None:
								_A	:				Optional[int]   =      0

				if end is None:
								_A	:				Union[str, Any]   =      len(__lowercase   ) - 1

				if start >= end:
								return

				_A	:				Union[str, Any]   =      (start + end) // 2

				slowsort(__lowercase					,  __lowercase					,  __lowercase   )
				slowsort(__lowercase					,  mid + 1					,  __lowercase   )

				if sequence[end] < sequence[mid]:
								_A  ,				_A	:				Optional[int]   =      sequence[mid], sequence[end]

				slowsort(__lowercase					,  __lowercase					,  end - 1   )


if __name__ == "__main__":
	from doctest import testmod

	testmod()



