



'''simple docstring'''

from typing import TYPE_CHECKING

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


UpperCAmelCase      						=       {
    '''configuration_data2vec_audio''': ['''DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Data2VecAudioConfig'''],
    '''configuration_data2vec_text''': [
        '''DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Data2VecTextConfig''',
        '''Data2VecTextOnnxConfig''',
    ],
    '''configuration_data2vec_vision''': [
        '''DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Data2VecVisionConfig''',
        '''Data2VecVisionOnnxConfig''',
    ],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCAmelCase      						=       [
				    '''DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''Data2VecAudioForAudioFrameClassification''',
				    '''Data2VecAudioForCTC''',
				    '''Data2VecAudioForSequenceClassification''',
				    '''Data2VecAudioForXVector''',
				    '''Data2VecAudioModel''',
				    '''Data2VecAudioPreTrainedModel''',
				]
				UpperCAmelCase      						=       [
				    '''DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''Data2VecTextForCausalLM''',
				    '''Data2VecTextForMaskedLM''',
				    '''Data2VecTextForMultipleChoice''',
				    '''Data2VecTextForQuestionAnswering''',
				    '''Data2VecTextForSequenceClassification''',
				    '''Data2VecTextForTokenClassification''',
				    '''Data2VecTextModel''',
				    '''Data2VecTextPreTrainedModel''',
				]
				UpperCAmelCase      						=       [
				    '''DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''Data2VecVisionForImageClassification''',
				    '''Data2VecVisionForMaskedImageModeling''',
				    '''Data2VecVisionForSemanticSegmentation''',
				    '''Data2VecVisionModel''',
				    '''Data2VecVisionPreTrainedModel''',
				]

if is_tf_available():
				UpperCAmelCase      						=       [
				    '''TFData2VecVisionForImageClassification''',
				    '''TFData2VecVisionForSemanticSegmentation''',
				    '''TFData2VecVisionModel''',
				    '''TFData2VecVisionPreTrainedModel''',
				]

if TYPE_CHECKING:
				from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
				from .configuration_dataavec_text import (
				    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    DataaVecTextConfig,
				    DataaVecTextOnnxConfig,
				)
				from .configuration_dataavec_vision import (
				    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    DataaVecVisionConfig,
				    DataaVecVisionOnnxConfig,
				)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_dataavec_audio import (
								    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DataaVecAudioForAudioFrameClassification,
								    DataaVecAudioForCTC,
								    DataaVecAudioForSequenceClassification,
								    DataaVecAudioForXVector,
								    DataaVecAudioModel,
								    DataaVecAudioPreTrainedModel,
								)
								from .modeling_dataavec_text import (
								    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DataaVecTextForCausalLM,
								    DataaVecTextForMaskedLM,
								    DataaVecTextForMultipleChoice,
								    DataaVecTextForQuestionAnswering,
								    DataaVecTextForSequenceClassification,
								    DataaVecTextForTokenClassification,
								    DataaVecTextModel,
								    DataaVecTextPreTrainedModel,
								)
								from .modeling_dataavec_vision import (
								    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DataaVecVisionForImageClassification,
								    DataaVecVisionForMaskedImageModeling,
								    DataaVecVisionForSemanticSegmentation,
								    DataaVecVisionModel,
								    DataaVecVisionPreTrainedModel,
								)
				if is_tf_available():
								from .modeling_tf_dataavec_vision import (
								    TFDataaVecVisionForImageClassification,
								    TFDataaVecVisionForSemanticSegmentation,
								    TFDataaVecVisionModel,
								    TFDataaVecVisionPreTrainedModel,
								)

else:
				import sys

				UpperCAmelCase      						=       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


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())





