import java.util.*;

public class Euler308 {
    static long estimateUpperBoundForNthPrime(long n) {
        if (n < 6)
            return 15;
        double nd = (double) n;
        double estimate = nd * (Math.log(nd) + Math.log(Math.log(nd))) + 32.0;
        long bound = (long) Math.ceil(estimate);
        return Math.max(bound, 15);
    }

    static class SieveData {
        int[] primes;
        int primeCount;
        int[] spf;
    }

    static SieveData buildLinearSieve(int limit) {
        SieveData out = new SieveData();
        out.spf = new int[limit + 1];
        out.primes = new int[limit / 10 + 16];
        out.primeCount = 0;

        for (int i = 2; i <= limit; ++i) {
            if (out.spf[i] == 0) {
                out.spf[i] = i;
                if (out.primeCount == out.primes.length) {
                    out.primes = Arrays.copyOf(out.primes, out.primes.length * 2);
                }
                out.primes[out.primeCount++] = i;
            }

            for (int pIndex = 0; pIndex < out.primeCount; ++pIndex) {
                int p = out.primes[pIndex];
                long composite = (long) p * i;
                if (composite > limit)
                    break;
                out.spf[(int) composite] = p;
                if (p == out.spf[i])
                    break;
            }
        }
        return out;
    }

    static SieveData buildSieveWithPrimeCount(long targetIndex) {
        long limit = estimateUpperBoundForNthPrime(targetIndex);
        while (true) {
            if (limit > Integer.MAX_VALUE)
                throw new RuntimeException("Sieve too large");
            SieveData sieve = buildLinearSieve((int) limit);
            if (sieve.primeCount >= targetIndex) {
                return sieve;
            }
            limit *= 2;
        }
    }

    static long floorSumUpto(long n, long r) {
        if (r == 0)
            return 0;
        if (r > n)
            r = n;

        long sum = 0;
        long left = 1;
        while (left <= r) {
            long q = n / left;
            long right = n / q;
            if (right > r)
                right = r;
            sum += q * (right - left + 1);
            left = right + 1;
        }
        return sum;
    }

    static long floorSumRange(long n, long l, long r) {
        if (l > r || r == 0)
            return 0;
        return floorSumUpto(n, r) - floorSumUpto(n, l - 1);
    }

    static long candidateDeltaToNextStart(long n, long spfN) {
        long maxProperDivisor = n / spfN;
        long nonDivisorCount = (n > maxProperDivisor + 1) ? (n - maxProperDivisor - 1) : 0;
        long nonDivisorFloorSum = floorSumRange(n, maxProperDivisor + 1, n - 1);

        long setup = 2 * n - 1;
        long nonDivisorTotal = (6 * n + 2) * nonDivisorCount + 2 * nonDivisorFloorSum;
        long terminal = 5 * n + maxProperDivisor + 2 * (n / maxProperDivisor) + 2;

        return setup + nonDivisorTotal + terminal;
    }

    static long primeHitOffsetFromStart(long primeCandidate) {
        long nonDivisorFloorSum = floorSumRange(primeCandidate, 2, primeCandidate - 1);

        long setup = 2 * primeCandidate - 1;
        long nonDivisorTotal = (6 * primeCandidate + 2) * (primeCandidate - 2) + 2 * nonDivisorFloorSum;
        long primeBranchToHit = 6 * primeCandidate + 2;

        return setup + nonDivisorTotal + primeBranchToHit;
    }

    static long solveIterationsToPrimeIndex(long targetIndex) {
        if (targetIndex == 0)
            return 0;

        SieveData sieve = buildSieveWithPrimeCount(targetIndex);
        long primeTarget = sieve.primes[(int) (targetIndex - 1)];

        long startStep = 2;
        long foundPrimes = 0;

        for (long n = 2; n <= primeTarget; ++n) {
            long spfN = sieve.spf[(int) n];
            boolean isPrime = (spfN == n);

            if (isPrime) {
                long hitStep = startStep + primeHitOffsetFromStart(n);
                foundPrimes++;
                if (foundPrimes == targetIndex) {
                    return hitStep;
                }
            }

            startStep += candidateDeltaToNextStart(n, spfN);
        }

        return 0;
    }

    public static String solve() {
        return String.valueOf(solveIterationsToPrimeIndex(10001));
    }

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