import java.util.*;

public class Euler927 {

    static long modPow(long base, int exp, int mod) {
        if (mod == 1)
            return 0;
        long res = 1 % mod;
        long b = base % mod;
        while (exp > 0) {
            if ((exp & 1) != 0)
                res = (res * b) % mod;
            b = (b * b) % mod;
            exp >>= 1;
        }
        return res;
    }

    static long nextTerm(long x, int p, int mod) {
        if (p == 2) {
            return (x * x + 1L) % mod;
        }
        return (modPow(x, p, mod) + 1L) % mod;
    }

    static boolean hitsZero(int mod, int p) {
        if (mod == 1)
            return true;
        long start = 1L % mod;
        if (start == 0)
            return true;

        long tortoise = start;
        long hare = nextTerm(start, p, mod);
        if (hare == 0)
            return true;

        long power = 1;
        long lam = 1;
        while (tortoise != hare) {
            if (power == lam) {
                tortoise = hare;
                power <<= 1;
                lam = 0;
            }
            hare = nextTerm(hare, p, mod);
            if (hare == 0)
                return true;
            lam++;
        }
        return false;
    }

    static class Sieve {
        List<Integer> primes = new ArrayList<>();
        int[] spf;
    }

    static Sieve buildSieve(int n) {
        Sieve sieve = new Sieve();
        sieve.spf = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            if (sieve.spf[i] == 0) {
                sieve.spf[i] = i;
                sieve.primes.add(i);
            }
            for (int p : sieve.primes) {
                long v = (long) p * i;
                if (v > n || p > sieve.spf[i])
                    break;
                sieve.spf[(int) v] = p;
            }
        }
        return sieve;
    }

    static boolean isGoodPrime(int q, int[] spf) {
        if (q == 2)
            return true;

        int x = q - 1;
        List<Integer> factors = new ArrayList<>();
        while (x > 1) {
            int p = spf[x];
            factors.add(p);
            while (x % p == 0)
                x /= p;
        }

        Collections.sort(factors, Collections.reverseOrder());
        // Deduplicate
        List<Integer> uniqueFactors = new ArrayList<>();
        int last = -1;
        for (int p : factors) {
            if (p != last) {
                uniqueFactors.add(p);
                last = p;
            }
        }

        for (int p : uniqueFactors) {
            if (!hitsZero(q, p))
                return false;
        }
        return true;
    }

    static long total = 0;

    static void dfs(int idx, long current, List<Integer> good, long limit) {
        total += current;
        for (int i = idx; i < good.size(); ++i) {
            long p = good.get(i);
            if (current > limit / p)
                break;
            dfs(i + 1, current * p, good, limit);
        }
    }

    public static String solve(long n) {
        Sieve sieve = buildSieve((int) n);
        List<Integer> good = new ArrayList<>();
        for (int q : sieve.primes) {
            if (isGoodPrime(q, sieve.spf)) {
                good.add(q);
            }
        }

        total = 0;
        dfs(0, 1, good, n);
        return Long.toString(total);
    }

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