import java.util.*;
import java.util.concurrent.*;

public class Euler272 {
    static final long TARGET_LIMIT = 100_000_000_000L;
    static final long MIN_PROD_4_SPECIAL = 53_599L;
    static final long MIN_PROD_5_SPECIAL = 1_983_709L;
    static final long PRIME_BOUND_DENOMINATOR = 15_561L;
    static final long INFINITY = Long.MAX_VALUE;

    static int[] buildSpf(int limit) {
        int[] spf = new int[limit + 1];
        if (limit >= 1)
            spf[1] = 1;
        List<Integer> primes = new ArrayList<>();

        for (int i = 2; i <= limit; ++i) {
            if (spf[i] == 0) {
                spf[i] = i;
                primes.add(i);
            }
            for (int p : primes) {
                long composite = (long) i * p;
                if (composite > limit || p > spf[i])
                    break;
                spf[(int) composite] = p;
            }
        }
        return spf;
    }

    static class Solver {
        long limit;
        long maxCofactorLimit;
        List<Long> specialPrimes = new ArrayList<>();
        long[][] minProd;
        long[] prefixAllowedSum;

        Solver(long limit) {
            this.limit = limit;
            buildSpecialPrimes();
            buildMinProductTable();
            buildCofactorPrefix();
        }

        void buildSpecialPrimes() {
            long upperU64 = limit / PRIME_BOUND_DENOMINATOR;
            if (upperU64 < 7)
                return;

            int upper = (int) upperU64;
            boolean[] isPrime = new boolean[upper + 1];
            Arrays.fill(isPrime, true);
            isPrime[0] = false;
            isPrime[1] = false;

            for (int p = 2; (long) p * p <= upper; ++p) {
                if (isPrime[p]) {
                    for (int multiple = p * p; multiple <= upper; multiple += p) {
                        isPrime[multiple] = false;
                    }
                }
            }

            for (int p = 7; p <= upper; ++p) {
                if (isPrime[p] && p % 3 == 1) {
                    specialPrimes.add((long) p);
                }
            }
        }

        void buildMinProductTable() {
            int n = specialPrimes.size();
            minProd = new long[5][n + 1];
            for (int r = 0; r < 5; ++r) {
                Arrays.fill(minProd[r], INFINITY);
            }
            for (int i = 0; i <= n; ++i) {
                minProd[0][i] = 1;
            }
            for (int i = n - 1; i >= 0; --i) {
                for (int r = 1; r <= 4; ++r) {
                    long tail = minProd[r - 1][i + 1];
                    if (tail == INFINITY || specialPrimes.get(i) > INFINITY / tail) {
                        minProd[r][i] = INFINITY;
                    } else {
                        minProd[r][i] = specialPrimes.get(i) * tail;
                    }
                }
            }
        }

        void buildCofactorPrefix() {
            long maxCaseWithout9 = limit / MIN_PROD_5_SPECIAL;
            long maxCaseWith9 = limit / (9L * MIN_PROD_4_SPECIAL);
            maxCofactorLimit = Math.max(maxCaseWithout9, maxCaseWith9);

            if (maxCofactorLimit == 0) {
                prefixAllowedSum = new long[1];
                return;
            }

            int maxLimit = (int) maxCofactorLimit;
            int[] spf = buildSpf(maxLimit);
            boolean[] valid = new boolean[maxLimit + 1];
            valid[1] = true;

            for (int n = 2; n <= maxLimit; ++n) {
                int p = spf[n];
                valid[n] = valid[n / p] && (p % 3 == 2);
            }

            prefixAllowedSum = new long[maxLimit + 1];
            for (int n = 1; n <= maxLimit; ++n) {
                prefixAllowedSum[n] = prefixAllowedSum[n - 1] + (valid[n] ? n : 0);
            }
        }

        long sumAllowedWithout3(long m) {
            if (m > maxCofactorLimit)
                m = maxCofactorLimit;
            return prefixAllowedSum[(int) m];
        }

        long sumAllowedWithOptionalSingle3(long m) {
            if (m > maxCofactorLimit)
                m = maxCofactorLimit;
            long noThree = sumAllowedWithout3(m);
            long oneThree = 3L * sumAllowedWithout3(m / 3);
            return noThree + oneThree;
        }

        long dfsCaseWithout9(int start, int remaining, long product) {
            if (remaining == 0) {
                long cofactorLimit = limit / product;
                return product * sumAllowedWithOptionalSingle3(cofactorLimit);
            }

            long total = 0;
            int n = specialPrimes.size();

            for (int i = start; i < n; ++i) {
                long minRest = minProd[remaining - 1][i + 1];
                if (minRest == INFINITY)
                    break;
                if (product > limit / minRest)
                    break;

                long maxPrimePower = (limit / product) / minRest;
                long p = specialPrimes.get(i);
                if (p > maxPrimePower)
                    break;

                for (long power = p; power <= maxPrimePower;) {
                    total += dfsCaseWithout9(i + 1, remaining - 1, product * power);
                    if (power > maxPrimePower / p)
                        break;
                    power *= p;
                }
            }

            return total;
        }

        long dfsCaseWith9(int start, int remaining, long product, long specialLimit) {
            if (remaining == 0) {
                long total = 0;
                long maxThreePower = limit / product;

                for (long threePower = 9; threePower <= maxThreePower;) {
                    long cofactorLimit = limit / (product * threePower);
                    total += product * threePower * sumAllowedWithout3(cofactorLimit);
                    if (threePower > maxThreePower / 3)
                        break;
                    threePower *= 3;
                }
                return total;
            }

            long total = 0;
            int n = specialPrimes.size();

            for (int i = start; i < n; ++i) {
                long minRest = minProd[remaining - 1][i + 1];
                if (minRest == INFINITY)
                    break;
                if (product > specialLimit / minRest)
                    break;

                long maxPrimePower = (specialLimit / product) / minRest;
                long p = specialPrimes.get(i);
                if (p > maxPrimePower)
                    break;

                for (long power = p; power <= maxPrimePower;) {
                    total += dfsCaseWith9(i + 1, remaining - 1, product * power, specialLimit);
                    if (power > maxPrimePower / p)
                        break;
                    power *= p;
                }
            }

            return total;
        }

        long solveParallel() {
            List<Integer> rootsWithout = new ArrayList<>();
            for (int i = 0; i < specialPrimes.size(); ++i) {
                long minRest = minProd[4][i + 1];
                if (minRest == INFINITY)
                    break;
                if (specialPrimes.get(i) > limit / minRest)
                    break;
                rootsWithout.add(i);
            }

            long specialLimit = limit / 9;
            List<Integer> rootsWith = new ArrayList<>();
            for (int i = 0; i < specialPrimes.size(); ++i) {
                long minRest = minProd[3][i + 1];
                if (minRest == INFINITY)
                    break;
                if (specialPrimes.get(i) > specialLimit / minRest)
                    break;
                rootsWith.add(i);
            }

            int threads = Math.max(1, Runtime.getRuntime().availableProcessors());
            ExecutorService executor = Executors.newFixedThreadPool(threads);
            List<Future<Long>> futuresWithout = new ArrayList<>();
            List<Future<Long>> futuresWith = new ArrayList<>();

            for (int root : rootsWithout) {
                futuresWithout.add(executor.submit(() -> {
                    long p = specialPrimes.get(root);
                    long minRest = minProd[4][root + 1];
                    long maxPrimePower = limit / minRest;
                    long local = 0;
                    for (long power = p; power <= maxPrimePower;) {
                        local += dfsCaseWithout9(root + 1, 4, power);
                        if (power > maxPrimePower / p)
                            break;
                        power *= p;
                    }
                    return local;
                }));
            }

            for (int root : rootsWith) {
                futuresWith.add(executor.submit(() -> {
                    long p = specialPrimes.get(root);
                    long minRest = minProd[3][root + 1];
                    long maxPrimePower = specialLimit / minRest;
                    long local = 0;
                    for (long power = p; power <= maxPrimePower;) {
                        local += dfsCaseWith9(root + 1, 3, power, specialLimit);
                        if (power > maxPrimePower / p)
                            break;
                        power *= p;
                    }
                    return local;
                }));
            }

            long total = 0;
            try {
                for (Future<Long> f : futuresWithout)
                    total += f.get();
                for (Future<Long> f : futuresWith)
                    total += f.get();
            } catch (Exception e) {
                e.printStackTrace();
            }

            executor.shutdown();
            return total;
        }
    }

    public static String solve() {
        Solver solver = new Solver(TARGET_LIMIT);
        return String.valueOf(solver.solveParallel());
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}