





'''simple docstring'''

lowercase_					= {}





def lowerCamelCase						(     __lowerCamelCase :    int					,       __lowerCamelCase :    int					,       __lowerCamelCase :    int    )						->List[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
    _SCREAMING_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
    _SCREAMING_SNAKE_CASE									=			_calculate(days - 1					,       __lowerCamelCase					,       late + 1    )

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

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

    _SCREAMING_SNAKE_CASE									=			state_late + state_absent + state_ontime

    _SCREAMING_SNAKE_CASE									=			prizestrings
    return prizestrings





def lowerCamelCase						(     __lowerCamelCase :    int = 30    )						->List[Any]:
    return _calculate(__lowerCamelCase					,       absent=0					,       late=0    )


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




from math import factorial, radians




def       _snake_case	(   lowerCAmelCase							:   float   , lowerCAmelCase							:   int = 1_8   , lowerCAmelCase							:   int = 1_0	):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		List[str]				      =    angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0)

		# Converting from degrees to radians
		SCREAMING_SNAKE_CASE_  :		Tuple				      =    radians(lowerCAmelCase	)

		SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    angle_in_radians
		SCREAMING_SNAKE_CASE_  :		List[str]				      =    3
		SCREAMING_SNAKE_CASE_  :		str				      =    -1

		for _ in range(lowerCAmelCase	):
				result += (b * (angle_in_radians**a)) / factorial(lowerCAmelCase	)

				SCREAMING_SNAKE_CASE_  :		Dict				      =    -b  # One positive term and the next will be negative and so on...
				a += 2  # Increased by 2 for every term.

		return round(lowerCAmelCase   , lowerCAmelCase	)


if __name__ == "__main__":
		__import__('''doctest''').testmod()
