
__magic_name__            =  {}





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase    ,		__lowerCAmelCase    ,		__lowerCAmelCase							):

    # 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    ,		__lowerCAmelCase    ,		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    ,		__lowerCAmelCase    ,		0							)

    snake_case__						=				state_late + state_absent + state_ontime

    snake_case__						=				prizestrings
    return prizestrings





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase = 30							):
    return _calculate(__lowerCAmelCase    ,		absent=0    ,		late=0							)


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





from __future__ import annotations

from fractions import Fraction





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase    ,		__lowerCAmelCase							):
    return (
        num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
    )





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase							):
    snake_case__						=				[]
    snake_case__						=				11
    snake_case__						=				int("1" + "0" * digit_len							)
    for num in range(__lowerCAmelCase    ,		__lowerCAmelCase							):
        while den <= 99:
            if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
                if is_digit_cancelling(__lowerCAmelCase    ,		__lowerCAmelCase							):
                    solutions.append(F"""{num}/{den}"""							)
            den += 1
        num += 1
        snake_case__						=				10
    return solutions





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase = 2							):
    snake_case__						=				1.0
    for fraction in fraction_list(__lowerCAmelCase							):
        snake_case__						=				Fraction(__lowerCAmelCase							)
        result *= frac.denominator / frac.numerator
    return int(__lowerCAmelCase							)


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



