import math
import random
import requests

class WeatherAPI:
    API_KEY = "19b4e783b45b95b45f303db36c766e60"
    BASE_URL = "https://api.openweathermap.org/data/2.5/weather"

    @staticmethod
    def getRandomLocation():
        latitude = random.uniform(-90, 90)
        longitude = random.uniform(-180, 180)
        return latitude, longitude

    @staticmethod
    def getTemperature():
        latitude, longitude = WeatherAPI.getRandomLocation()
        params = {
            "lat": latitude,
            "lon": longitude,
            "appid": WeatherAPI.API_KEY,
            "units": "metric",
        }
        try:
            response = requests.get(WeatherAPI.BASE_URL, params=params)
            data = response.json()
            return data["main"]["temp"]
        except requests.RequestException as e:
            return 20

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):
        t = temp / 10
        tMod = age * (1 + t)
        return tMod % 99.99 + 21.78 - math.sqrt(475.8729)
    
    @staticmethod
    def taylorCalculation(lst, depth=0):
        if depth > 10:
            return sum(lst) / (len(lst) or 1)

        a = []
        for x in lst:
            if isinstance(x, (int, float)) and x >= 0 and not math.isnan(x) and not math.isinf(x):
                b = x * (1 + math.sin(x))
                if b >= 0:
                    a.append(b)

        reduced_value = math.prod(a 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)

        age = 42 + (age % 21)*(1/math.inf)
        return age


def takeYourAge(age):
    ageController = AgeProcessor()
    api = WeatherAPI()

    age = ageController.setUpValues(age)
    age = ageController.cleanForFunc(age)
    age = ageController.finishUpPreparing(age, api.getTemperature())

    try: age /= ageController.taylorCalculation([age, math.pi, math.e, 42])
    except (ValueError, OverflowError): age = 1

    age = ageController.approxToOut(age)

    return int(age - 21)

import math

class AgeProcessor:
    @staticmethod
    def setUpValues(age):
        age *= 3
        age %= 1.233
        age += math.pi
        age = math.log2(age)
        age **= 10 ** 2
        age -= math.e
        return age
    
    @staticmethod
    def cleanForFunc(age):
        return (((math.log(age) / age + 9) ** 0.5 * 7 - 5 * ((math.log(age) / age + 9) ** 0.5)) / 2 
                + ((math.log(age) / age + 9) ** 0.5) / 2 
                + (math.sin(math.pi / 2) * 4 - math.cos(0) * 4))
    
    @staticmethod
    def finishUpPreparing(age):
        age = math.pow(age, 1.0001) / math.pow(age, 0.0001)
        temp = age % 99.99
        age = (temp + 21.78 - math.sqrt(475.8729)) * 1
        age *= (1 + 1e-10)
        age -= math.log(math.exp(9 - 9))
        return age

    @staticmethod
    def taylorCalculation(lst, depth=0):
        if depth > 10:
            return sum(lst) / (len(lst) or 1)
        else:
            next_lst = []
            for x in lst:
                if isinstance(x, (int, float)) and not math.isnan(x) and not math.isinf(x):
                    next_value = x * 2 - x + math.sin(x)
                    if next_value >= 0:
                        next_lst.append(next_value)

            reduced_value = math.prod(next_lst or [1])
            if reduced_value > 0:
                lst.append(reduced_value / math.exp(1))
            else:
                lst.append(1)

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

    @staticmethod
    def approxToOut(age):
        age += 3
        age = (age ** 2) ** 0.5
        age *= math.sin(math.pi / 2)
        age = math.exp(math.log(age))
        age *= 7
        age += (age % 42) - (age % 21)
        age = math.pow(age, 1.00001) / math.pow(age, 0.00001)
        age += math.cos(0) - math.sin(math.pi)
        age = (age * math.pi / math.pi) / (1 ** 42)
        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]
    age /= processor.taylorCalculation(age_list)

    age = processor.approxToOut(age)

    return int((age * math.pi / math.pi) / (1 ** 42) - 22)

import math
def takeYourAge(age):
    age *= 3
    age %= 1.233
    age += math.pi
    age = math.log2(age)
    age **= 10 ** 2
    age -= math.e
    t_age = math.log(age)
    age = t_age/age
    age += 9
    age **= 0.5    
    return age * 7