





snake_case_           =      {}






def lowerCamelCase__   (							snake_case_     :  int	,				snake_case_     :  int	,				snake_case_     :  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
   __snake_case								=       (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
   __snake_case								=       _calculate(days - 1	,				snake_case_	,				late + 1	)

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

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

   __snake_case								=       state_late + state_absent + state_ontime

   __snake_case								=       prizestrings
   return prizestrings






def lowerCamelCase__   (							snake_case_     :  int = 30	)				->    int:
   return _calculate(snake_case_	,				absent=0	,				late=0	)


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








from typing import List, Union

import numpy as np

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
    from PIL import Image

    from ..image_utils import load_image

if is_torch_available():
    import torch

    from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING

snake_case_           =      logging.get_logger(__name__)

@add_end_docstrings(_UpperCAmelCase  )
class 		SCREAMING_SNAKE_CASE__    (	_UpperCAmelCase  ):


      def __init__(self	:				int    ,      *a__	:				List[Any]    ,      **a__	:				Dict				):





         """simple docstring"""



         super().__init__(*a__    ,      **a__				)
         requires_backends(self    ,      '''vision'''				)
         self.check_model_type(a__				)


      def __call__(self	:				Optional[Any]    ,      a__	:				Union[str, List[str], "Image.Image", List["Image.Image"]]    ,      **a__	:				List[str]				):





         """simple docstring"""



         return super().__call__(a__    ,      **a__				)


      def        a			(self	:				int    ,      **a__	:				int				):





         """simple docstring"""



         return {}, {}, {}


      def        a			(self	:				Optional[int]    ,      a__	:				Optional[int]				):





         """simple docstring"""



         __snake_case								=       load_image(a__				)
         __snake_case								=       image.size
         __snake_case								=       self.image_processor(images=a__    ,      return_tensors=self.framework				)
         return model_inputs


      def        a			(self	:				List[Any]    ,      a__	:				Union[str, Any]				):





         """simple docstring"""



         __snake_case								=       self.model(**a__				)
         return model_outputs


      def        a			(self	:				int    ,      a__	:				str				):





         """simple docstring"""



         __snake_case								=       model_outputs.predicted_depth
         __snake_case								=       torch.nn.functional.interpolate(
             predicted_depth.unsqueeze(1				)    ,      size=self.image_size[::-1]    ,      mode='''bicubic'''    ,      align_corners=a__				)
         __snake_case								=       prediction.squeeze().cpu().numpy()
         __snake_case								=       (output * 255 / np.max(a__				)).astype('''uint8'''				)
         __snake_case								=       Image.fromarray(a__				)
         __snake_case								=       {}
         __snake_case								=       predicted_depth
         __snake_case								=       depth
         return output_dict

