



'''simple docstring'''

__lowerCAmelCase		     =  {}



def 	__lowerCamelCase	( lowerCAmelCase_		,     lowerCAmelCase_		,     lowerCAmelCase_    )     -> 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	: 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	: str								=				_calculate(days - 1		,     lowerCAmelCase_		,     late + 1    )

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

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

		_a	: List[str]								=				state_late + state_absent + state_ontime

		_a	: Optional[Any]								=				prizestrings
		return prizestrings



def 	__lowerCamelCase	( lowerCAmelCase_ = 30    )     -> int:
		return _calculate(lowerCAmelCase_		,     absent=0		,     late=0    )


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









'''simple docstring'''

from abc import ABC, abstractmethod
from argparse import ArgumentParser

class       __magic_name__		(       _UpperCamelCase  ):







							@staticmethod
							@abstractmethod
							def 				__lowercase     (				_UpperCAmelCase   :			ArgumentParser						):
									raise NotImplementedError()







							@abstractmethod
							def 				__lowercase     (				self   :			str						):
									raise NotImplementedError()




