





'''simple docstring'''


lowerCAmelCase					:     List[str]												={}
def 							UpperCAmelCase_  (						__lowerCamelCase					:					Optional[Any]	,__lowerCamelCase					:					Optional[Any]	,__lowerCamelCase					:					Any ):





   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
   lowercase_			: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
   lowercase_			:Dict    			= _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
   lowercase_			:Union[str, Any]    			= _calculate(days - 1	,absent + 1	,0 )

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

   lowercase_			:List[Any]    			= state_late + state_absent + state_ontime

   lowercase_			:Union[str, Any]    			= prizestrings
   return prizestrings
def 							UpperCAmelCase_  (						__lowerCamelCase					:					Optional[int] = 30 ):
   return _calculate(__snake_case	,absent=0	,late=0 )


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




"""simple docstring"""





from __future__ import annotations



def       lowerCamelCase__		(			__snake_case,     __snake_case,     __snake_case	)							->		int | float:


					"""simple docstring"""





					if len(__snake_case	) == 0:
										raise ValueError('''find_max() arg is an empty sequence'''	)
					if (
					    left >= len(__snake_case	)
					    or left < -len(__snake_case	)
					    or right >= len(__snake_case	)
					    or right < -len(__snake_case	)
					):
										raise IndexError('''list index out of range'''	)
					if left == right:
										return nums[left]
					_UpperCamelCase							 =  (left + right) >> 1  # the middle
					_UpperCamelCase							 =  find_max(__snake_case,     __snake_case,     __snake_case	)  # find max in range[left, mid]
					_UpperCamelCase							 =  find_max(__snake_case,     mid + 1,     __snake_case	)  # find max in range[mid + 1, right]

					return left_max if left_max >= right_max else right_max


if __name__ == "__main__":
				import doctest

				doctest.testmod(verbose=True)






