





_snake_case  :    Dict						    =  {}

def   a_    ( lowerCAmelCase_      :			Any,	lowerCAmelCase_      :			Dict,	lowerCAmelCase_      :			str	):

   # 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
   __lowerCAmelCase								=	(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								=	_calculate(days - 1,	lowerCAmelCase_,	late + 1	)

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

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

   __lowerCAmelCase								=	state_late + state_absent + state_ontime

   __lowerCAmelCase								=	prizestrings
   return prizestrings

def   a_    ( lowerCAmelCase_      :			Dict = 30	):
   return _calculate(lowerCAmelCase_,	absent=0,	late=0	)


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





from typing import TYPE_CHECKING

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


__lowerCAmelCase		       =							{
    '''configuration_canine''': ['''CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CanineConfig'''],
    '''tokenization_canine''': ['''CanineTokenizer'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCAmelCase		       =							[
     '''CANINE_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''CanineForMultipleChoice''',
     '''CanineForQuestionAnswering''',
     '''CanineForSequenceClassification''',
     '''CanineForTokenClassification''',
     '''CanineLayer''',
     '''CanineModel''',
     '''CaninePreTrainedModel''',
     '''load_tf_weights_in_canine''',
 ]


if TYPE_CHECKING:
 from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig
 from .tokenization_canine import CanineTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_canine import (
      CANINE_PRETRAINED_MODEL_ARCHIVE_LIST,
      CanineForMultipleChoice,
      CanineForQuestionAnswering,
      CanineForSequenceClassification,
      CanineForTokenClassification,
      CanineLayer,
      CanineModel,
      CaninePreTrainedModel,
      load_tf_weights_in_canine,
  )


else:
 import sys

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


