#include <iostream>
#include <vector>
#include <unordered_map>

bool IsPrime(int64_t number) {
    int64_t divisor = 2;
    while (divisor * divisor <= number) {
        if (number % divisor == 0) {
            return false;
        }
        ++divisor;
    }
    return true;
}

int64_t MinDivisor(int64_t number) {
    int64_t divisor = 2;
    while (divisor * divisor <= number) {
        if (number % divisor == 0) {
            return divisor;
        }
        ++divisor;
    }
    return number;
}

// n = p_1^q_1 * p_2^q_2 ... p_n^q_n

// 27 = {3: 3}


// p^n: n + 1
// pq: 4
// p^n q^m: (n + 1)(m + 1)
// n = p_1^q_1 * p_2^q_2 ... p_n^q_n: (q_1 + 1)...(q_n + 1)

int64_t kPrime = 1e9 + 9;

int64_t Pow(int64_t a, int64_t n, int64_t p) {
    if (n == 0) {
        return 1;
    }
    if (n % 2 == 0) {
        return Pow(a * a, n / 2, p) % p;
    }
    return Pow(a, n - 1, p) * a % p;
}


// 2^17 = 2^16 * 2 = (2^8)^2 * 2 = (((2^2)^2)^2)^2 * 2
// log n

std::unordered_map<int64_t, int64_t> Factorization(int64_t number) {
    int64_t divisor = 2;
    std::unordered_map<int64_t, int64_t> factorization;
    while (divisor * divisor <= number) {
        while (number % divisor == 0) {
            number /= divisor;
            ++factorization[divisor];
        }
        ++divisor;
    }
    if (number > 1) {
        factorization[number] = 1;
    }
    return factorization;
}

int64_t DivisorsCount(int64_t number) {
    auto factorization = Factorization(number);
    int64_t divisors_count = 1;
    for (auto [_, degree]: factorization) {
        divisors_count *= degree + 1;
    }
    return divisors_count;
}

int64_t DivisorsSum(int64_t number) {
    auto factorization = Factorization(number);
    int64_t divisors_sum = 1;
    for (auto [prime, degree]: factorization) {
        divisors_sum *= (Pow(prime, degree + 1, kPrime) - 1) / (prime - 1);
    }
    return divisors_sum;
}

int main() {
    int64_t number;
    std::cin >> number;
    std::cout << DivisorsSum(number);
    return 0;
}

// p: p + 1
// p^2: p^
// p^n: 1 + ... + p^n: (p^(n + 1) - 1) / (p - 1)
// p_1^q_1 * p_2^q_2 ... p_n^q_n: (p_1^(q_1 + 1) - 1) / (p_1 - 1) * .. * (p_n^(q_n + 1) - 1) / (p_n - 1)

// p^(n + 1) - 1 = p^(n + 1) - 1^(n + 1) = (p - 1)(o^n + ... + 1)