


'''simple docstring'''




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

def 			__UpperCamelCase    (    _A    :				int					,   _A    :				int					,   _A    :				int				)    ->      int:




	"""simple docstring"""





	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
	lowerCAmelCase					:    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
	lowerCAmelCase					:    str      							= _calculate(days - 1					,   _A					,   late + 1				)

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

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

	lowerCAmelCase					:    Any      							= state_late + state_absent + state_ontime

	lowerCAmelCase					:    Any      							= prizestrings
	return prizestrings

def 			__UpperCamelCase    (    _A    :				int = 30				)    ->      int:




	"""simple docstring"""





	return _calculate(_A					,   absent=0					,   late=0				)


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




'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


_lowerCAmelCase  :		int		     =	{
    'configuration_nezha': ['NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'NezhaConfig'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCAmelCase  :		Tuple		     =	[
				    'NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'NezhaForNextSentencePrediction',
				    'NezhaForMaskedLM',
				    'NezhaForPreTraining',
				    'NezhaForMultipleChoice',
				    'NezhaForQuestionAnswering',
				    'NezhaForSequenceClassification',
				    'NezhaForTokenClassification',
				    'NezhaModel',
				    'NezhaPreTrainedModel',
				]


if TYPE_CHECKING:
				from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_nezha import (
								    NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
								    NezhaForMaskedLM,
								    NezhaForMultipleChoice,
								    NezhaForNextSentencePrediction,
								    NezhaForPreTraining,
								    NezhaForQuestionAnswering,
								    NezhaForSequenceClassification,
								    NezhaForTokenClassification,
								    NezhaModel,
								    NezhaPreTrainedModel,
								)


else:
				import sys

				_lowerCAmelCase  :		str		     =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
