





"""simple docstring"""





__A											=		{}
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->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
  lowerCAmelCase__			:Dict											=							(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__			:str											=							_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__			:int											=							_calculate(days - 1     ,   absent + 1     ,   0			)

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

  lowerCAmelCase__			:Tuple											=							state_late + state_absent + state_ontime

  lowerCAmelCase__			:str											=							prizestrings
  return prizestrings
def  __A   (_SCREAMING_SNAKE_CASE = 30			)					->int:





  """simple docstring"""


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


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




def 				UpperCamelCase_(      lowerCamelCase_ )    ->						int:
    if not numbers:
        return 0

    if not isinstance(lowerCamelCase_							, (list, tuple) ) or not all(
        isinstance(lowerCamelCase_							, lowerCamelCase_ ) for number in numbers ):
        raise ValueError('numbers must be an iterable of integers' )

    _lowercase       :							int      		=		numbers[0]

    for i in range(1							, len(lowerCamelCase_ ) ):
        # update the maximum and minimum subarray products
        _lowercase       :							Union[str, Any]      		=		numbers[i]
        if number < 0:
            _lowercase		,				_lowercase       :							Any      		=		min_till_now, max_till_now
        _lowercase       :							Union[str, Any]      		=		max(lowerCamelCase_							, max_till_now * number )
        _lowercase       :							Union[str, Any]      		=		min(lowerCamelCase_							, min_till_now * number )

        # update the maximum product found till now
        _lowercase       :							Optional[Any]      		=		max(lowerCamelCase_							, lowerCamelCase_ )

    return max_prod


