



'''simple docstring'''
snake_case_			:     dict[tuple[int, int, int], int]  	=  {}






def A__   (					UpperCAmelCase_  ,  UpperCAmelCase_  ,  UpperCAmelCase_							):

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

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

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

						_UpperCamelCase :		Any			    =       state_late + state_absent + state_ontime

						_UpperCamelCase :		Dict			    =       prizestrings
						return prizestrings






def A__   (					UpperCAmelCase_ = 3_0							):
						return _calculate(UpperCAmelCase_  ,  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


snake_case_			:     Any  	=  {
    'configuration_mvp': ['MVP_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MvpConfig', 'MvpOnnxConfig'],
    'tokenization_mvp': ['MvpTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     Dict  	=  ['MvpTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					snake_case_			:     List[Any]  	=  [
					    'MVP_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'MvpForCausalLM',
					    'MvpForConditionalGeneration',
					    'MvpForQuestionAnswering',
					    'MvpForSequenceClassification',
					    'MvpModel',
					    'MvpPreTrainedModel',
					]

if TYPE_CHECKING:
					from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig
					from .tokenization_mvp import MvpTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_mvp_fast import MvpTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_mvp import (
										    MVP_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MvpForCausalLM,
										    MvpForConditionalGeneration,
										    MvpForQuestionAnswering,
										    MvpForSequenceClassification,
										    MvpModel,
										    MvpPreTrainedModel,
										)

else:
					import sys

					snake_case_			:     Optional[Any]  	=  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


