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




def       _snake_case	(   lowerCAmelCase							:   int   , lowerCAmelCase							:   int   , lowerCAmelCase							:   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
		SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    (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
		SCREAMING_SNAKE_CASE_  :		Tuple				      =    _calculate(days - 1   , lowerCAmelCase   , late + 1	)

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

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

		SCREAMING_SNAKE_CASE_  :		str				      =    state_late + state_absent + state_ontime

		SCREAMING_SNAKE_CASE_  :		Dict				      =    prizestrings
		return prizestrings




def       _snake_case	(   lowerCAmelCase							:   int = 3_0	):
		"""simple docstring"""







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


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

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__lowerCamelCase					:	Dict       =  {'''configuration_vit_mae''': ['''VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViTMAEConfig''']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__lowerCamelCase					:	Any       =  [
		    '''VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''ViTMAEForPreTraining''',
		    '''ViTMAELayer''',
		    '''ViTMAEModel''',
		    '''ViTMAEPreTrainedModel''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__lowerCamelCase					:	Optional[Any]       =  [
		    '''TFViTMAEForPreTraining''',
		    '''TFViTMAEModel''',
		    '''TFViTMAEPreTrainedModel''',
		]

if TYPE_CHECKING:
		from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_vit_mae import (
				    VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ViTMAEForPreTraining,
				    ViTMAELayer,
				    ViTMAEModel,
				    ViTMAEPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel


else:
		import sys

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