


lowercase_	   =     {}
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):

 # 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		:							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
 __lowerCamelCase		:							Tuple		 =						_calculate(days - 1      ,	SCREAMING_SNAKE_CASE__      ,	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		:							Union[str, Any]		 =						_calculate(days - 1      ,	SCREAMING_SNAKE_CASE__      ,	0						)

 __lowerCamelCase		:							int		 =						state_late + state_absent + state_ontime

 __lowerCamelCase		:							List[str]		 =						prizestrings
 return prizestrings
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__ = 30						):
 return _calculate(SCREAMING_SNAKE_CASE__      ,	absent=0      ,	late=0						)


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





from typing import TYPE_CHECKING

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


lowercase_	   =     {
    'configuration_convnext': ['CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ConvNextConfig', 'ConvNextOnnxConfig']
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase_	   =     ['ConvNextFeatureExtractor']
       lowercase_	   =     ['ConvNextImageProcessor']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase_	   =     [
           'CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'ConvNextForImageClassification',
           'ConvNextModel',
           'ConvNextPreTrainedModel',
           'ConvNextBackbone',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowercase_	   =     [
           'TFConvNextForImageClassification',
           'TFConvNextModel',
           'TFConvNextPreTrainedModel',
       ]

if TYPE_CHECKING:
       from .configuration_convnext import CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvNextConfig, ConvNextOnnxConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_convnext import ConvNextFeatureExtractor
              from .image_processing_convnext import ConvNextImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_convnext import (
                  CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  ConvNextBackbone,
                  ConvNextForImageClassification,
                  ConvNextModel,
                  ConvNextPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_convnext import TFConvNextForImageClassification, TFConvNextModel, TFConvNextPreTrainedModel


else:
       import sys

       lowercase_	   =     _LazyModule(__name__, globals()['__file__'], _import_structure)

