import math

class AgeProcessor:
    @staticmethod
    def setUpValues(age):
        age = math.log2(age * 3 % 1.233 + math.pi)
        age **= 100
        age -= math.e
        return age
    
    @staticmethod
    def cleanForFunc(age):
        log_term = math.log(age) / age + 9
        root_term = log_term ** 0.5
        return (root_term * (7 - 5) + root_term) / 2 + 4
    
    @staticmethod
    def finishUpPreparing(age):
        temp = age % 99.99
        age = temp + 21.78 - math.sqrt(475.8729)
        return age
    
    @staticmethod
    def taylorCalculation(lst, depth=0):
        # Termination condition for recursion
        if depth > 10:
            return sum(lst) / (len(lst) or 1)

        # Filter out invalid or infinite values
        next_lst = []
        for x in lst:
            if isinstance(x, (int, float)) and x >= 0 and not math.isnan(x) and not math.isinf(x):
                next_value = x * (1 + math.sin(x))
                if next_value >= 0:
                    next_lst.append(next_value)

        # Ensure `next_lst` is not empty to avoid issues
        reduced_value = math.prod(next_lst or [1]) / math.exp(1)
        lst.append(reduced_value if reduced_value > 0 else 1)

        return AgeProcessor.taylorCalculation(lst[::-1], depth + 1)

    @staticmethod
    def approxToOut(age):
        age = abs(age + 3)
        age = math.exp(math.log(age)) * 7
        age += (age % 42) - (age % 21)
        return age


def takeYourAge(age):
    processor = AgeProcessor()

    age = processor.setUpValues(age)
    age = processor.cleanForFunc(age)
    age = processor.finishUpPreparing(age)

    age_list = [age, math.pi, math.e, 42]
    try:
        age /= processor.taylorCalculation(age_list)
    except (ValueError, OverflowError):
        age = 1  # Fallback in case of error

    age = processor.approxToOut(age)

    return int(age - 21)