import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Euler536 {
    static long gcd(long a, long b) {
        while (b != 0) {
            long t = a % b;
            a = b;
            b = t;
        }
        return a;
    }

    static long modInv(long a, long mod) {
        if (mod == 1)
            return 0;
        long m0 = mod;
        long y = 0, x = 1;
        a = a % mod;
        while (a > 1) {
            long q = a / mod;
            long t = mod;
            mod = a % mod;
            a = t;
            t = y;
            y = x - q * y;
            x = t;
        }
        if (x < 0)
            x += m0;
        return x;
    }

    static class CRTRes {
        long r, m;
        boolean ok;

        CRTRes(long r, long m, boolean ok) {
            this.r = r;
            this.m = m;
            this.ok = ok;
        }
    }

    static CRTRes crtMerge(long r1, long m1, long r2, long m2, long maxN) {
        if (m1 == 1)
            return new CRTRes(r2 % m2, m2, true);
        if (m2 == 1)
            return new CRTRes(r1 % m1, m1, true);
        long g = gcd(m1, m2);
        if ((r1 % g) != (r2 % g))
            return new CRTRes(0, 0, false);

        long m1_g = m1 / g;
        long m2_g = m2 / g;

        long diff = r2 - r1;
        long diff_g = diff / g;

        long inv = modInv(m1_g % m2_g, m2_g);
        if (inv == 0 && m2_g > 1)
            return new CRTRes(0, 0, false);

        long t = diff_g % m2_g;
        if (t < 0)
            t += m2_g;

        // Java handles 128-bit multiplication via BigInteger but here values fit in
        // long if we are careful.
        // Wait, m1_g * m2 can exceed long! But maxN = 10^12. If m exceeds 10^12, we
        // clamp.
        // Let's use BigInteger for CRT steps just to be safe.
        java.math.BigInteger big_t = java.math.BigInteger.valueOf(t).multiply(java.math.BigInteger.valueOf(inv))
                .mod(java.math.BigInteger.valueOf(m2_g));
        java.math.BigInteger newm = java.math.BigInteger.valueOf(m1_g).multiply(java.math.BigInteger.valueOf(m2));
        java.math.BigInteger newr = java.math.BigInteger.valueOf(r1)
                .add(java.math.BigInteger.valueOf(m1).multiply(big_t));

        long clamp_mod = maxN + 1;
        if (newm.compareTo(java.math.BigInteger.valueOf(clamp_mod)) > 0) {
            java.math.BigInteger rr = newr.remainder(newm);
            if (rr.compareTo(java.math.BigInteger.valueOf(maxN)) > 0)
                return new CRTRes(0, 0, false);
            return new CRTRes(rr.longValue(), clamp_mod, true);
        }
        return new CRTRes(newr.remainder(newm).longValue(), newm.longValue(), true);
    }

    static List<Integer> sievePrimes(int n) {
        boolean[] isPrime = new boolean[n + 1];
        java.util.Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i)
                    isPrime[j] = false;
            }
        }
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; i++)
            if (isPrime[i])
                primes.add(i);
        return primes;
    }

    static class Solver {
        long N;
        List<Integer> primes;
        Set<Long> found;
        static final long MAX_ENUM = 10000;

        Solver(long n) {
            N = n;
            int limit = (int) Math.sqrt(N) + 4;
            primes = sievePrimes(limit);
            found = new HashSet<>();
        }

        long[] congruenceForRemaining(List<Integer> B, long P) {
            long r = 0;
            long M = 1;
            for (int p : B) {
                long mod = p - 1;
                if (mod == 0)
                    return null;
                long a = (P / p) % mod;
                long g = gcd(a, mod);
                if (3 % g != 0)
                    return null;
                long mod2 = mod / g;
                if (mod2 == 1)
                    continue;

                long a2 = a / g;
                long rhs = (mod2 - ((3 / g) % mod2)) % mod2;
                long inv = modInv(a2 % mod2, mod2);
                if (inv == 0)
                    return null;
                long rp = (rhs * inv) % mod2;

                CRTRes merged = crtMerge(r, M, rp, mod2, N);
                if (!merged.ok)
                    return null;
                r = merged.r;
                M = merged.m;
            }
            return new long[] { r, M };
        }

        long maxRemainingProduct(int bound_exclusive, long cap) {
            long prod = 1;
            for (int p : primes) {
                if (p == 2)
                    continue;
                if (p >= bound_exclusive)
                    break;
                if (prod > cap / p)
                    return cap;
                prod *= p;
            }
            if (prod > cap)
                return cap;
            return prod;
        }

        boolean factorSquarefreeBounded(long x, int bound_exclusive, List<Integer> factorsOut) {
            factorsOut.clear();
            if (x == 0 || (x & 1) == 0)
                return false;
            long n = x;
            for (int p : primes) {
                if ((long) p * p > n)
                    break;
                if (p >= bound_exclusive)
                    break;
                if (n % p == 0) {
                    factorsOut.add(p);
                    n /= p;
                    if (n % p == 0)
                        return false;
                }
            }
            if (n > 1) {
                if (n >= bound_exclusive)
                    return false;
                factorsOut.add((int) n);
            }
            return true;
        }

        boolean checkSolution(long m, List<Integer> factors) {
            long mp3 = m + 3;
            for (int p : factors) {
                long d = p - 1;
                if (d == 0 || mp3 % d != 0)
                    return false;
            }
            return true;
        }

        void enumerateAndCheck(List<Integer> B, long P, int min_big, long r, long M) {
            long limit = N / P;
            limit = Math.min(limit, maxRemainingProduct(min_big, limit));
            if (M == 0)
                return;

            List<Integer> factorsR = new ArrayList<>();
            List<Integer> factorsM = new ArrayList<>();

            for (long R = r; R <= limit;) {
                if (R != 0) {
                    if (factorSquarefreeBounded(R, min_big, factorsR)) {
                        factorsM.clear();
                        factorsM.addAll(B);
                        factorsM.addAll(factorsR);
                        long m = P * R;
                        if (m <= N && checkSolution(m, factorsM)) {
                            found.add(m);
                        }
                    }
                }
                if (R > limit - M)
                    break;
                R += M;
            }
        }

        void dfs(int max_prime_idx, List<Integer> B, long P) {
            int min_big = B.get(B.size() - 1);
            long[] rm = congruenceForRemaining(B, P);
            if (rm == null)
                return;
            long r = rm[0], M = rm[1];
            if (M == 0)
                return;

            long limit = N / P;
            limit = Math.min(limit, maxRemainingProduct(min_big, limit));
            if (limit == 0)
                return;

            long approx_cnt = limit / M + 1;
            if (approx_cnt <= MAX_ENUM) {
                enumerateAndCheck(B, P, min_big, r, M);
                return;
            }

            for (int idx = max_prime_idx - 1; idx >= 0; idx--) {
                int q = primes.get(idx);
                if (q == 2)
                    continue;
                if (P > N / q)
                    continue;
                long P2 = P * q;
                B.add(q);
                dfs(idx, B, P2);
                B.remove(B.size() - 1);
            }
        }

        long solve() {
            found.add(1L);
            if (N >= 2)
                found.add(2L);
            if (N >= 3)
                found.add(3L);
            if (N >= 5)
                found.add(5L);

            for (int i = primes.size() - 1; i >= 0; i--) {
                int pmax = primes.get(i);
                if (pmax < 7)
                    break;
                List<Integer> B = new ArrayList<>();
                B.add(pmax);
                dfs(i, B, pmax);
            }

            long sum = 0;
            for (long m : found) {
                if (m <= N)
                    sum += m;
            }
            return sum;
        }
    }

    public static String solve() {
        Solver solver = new Solver(1000000000000L);
        return Long.toString(solver.solve());
    }

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