import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Euler752 {
    static class Pair {
        long a, b;

        Pair(long a, long b) {
            this.a = a;
            this.b = b;
        }
    }

    static Pair mul(Pair x, Pair y, long mod) {
        return new Pair(
                (x.a * y.a + 7L * x.b * y.b) % mod,
                (x.a * y.b + x.b * y.a) % mod);
    }

    static Pair powU(long exp, long mod) {
        Pair result = new Pair(1L, 0L);
        Pair base = new Pair(1L, 1L);
        long e = exp;
        while (e > 0L) {
            if ((e & 1L) != 0L) {
                result = mul(result, base, mod);
            }
            base = mul(base, base, mod);
            e >>= 1L;
        }
        return result;
    }

    static int[] buildSpf(int n) {
        int[] spf = new int[n + 1];
        for (int i = 0; i <= n; ++i) {
            spf[i] = i;
        }
        for (int i = 2; i * i <= n; ++i) {
            if (spf[i] != i)
                continue;
            for (int j = i * i; j <= n; j += i) {
                if (spf[j] == j) {
                    spf[j] = i;
                }
            }
        }
        return spf;
    }

    static List<Integer> distinctPrimeFactors(int n, int[] spf) {
        List<Integer> factors = new ArrayList<>();
        while (n > 1) {
            int p = spf[n];
            factors.add(p);
            while (n % p == 0) {
                n /= p;
            }
        }
        return factors;
    }

    static long orderModPrime(int p, int[] spf) {
        if (p == 7) {
            return 7L;
        }

        long r = 1L;
        long b = 7L % p;
        long e = (p - 1) / 2;
        long pMod = p;
        while (e > 0L) {
            if ((e & 1L) != 0L) {
                r = (r * b) % pMod;
            }
            b = (b * b) % pMod;
            e >>= 1L;
        }
        long ls = r;

        long exponent;
        List<Integer> factors;
        if (ls == 1L) {
            exponent = p - 1;
            factors = distinctPrimeFactors(p - 1, spf);
        } else {
            exponent = (long) (p - 1) * (p + 1);
            factors = distinctPrimeFactors(p - 1, spf);
            factors.addAll(distinctPrimeFactors(p + 1, spf));
            Collections.sort(factors);
            List<Integer> uniqueFactors = new ArrayList<>();
            for (int f : factors) {
                if (uniqueFactors.isEmpty() || uniqueFactors.get(uniqueFactors.size() - 1) != f) {
                    uniqueFactors.add(f);
                }
            }
            factors = uniqueFactors;
        }

        long ord = exponent;
        for (int q : factors) {
            long qq = (long) q;
            while (ord % qq == 0L) {
                Pair test = powU(ord / qq, p);
                if (test.a == 1L && test.b == 0L) {
                    ord /= qq;
                } else {
                    break;
                }
            }
        }
        return ord;
    }

    static long gcd(long a, long b) {
        while (b != 0) {
            long temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    static long lcm(long a, long b) {
        return (a / gcd(a, b)) * b;
    }

    static long G(int n) {
        int limit = n + 1;
        int[] spf = buildSpf(limit);
        long[] ordPrimePower = new long[n + 1];

        for (int p = 5; p <= n; ++p) {
            if (spf[p] != p)
                continue;

            long ord = orderModPrime(p, spf);
            int pk = p;
            ordPrimePower[pk] = ord;

            while (pk <= n / p) {
                pk *= p;
                Pair test = powU(ord, pk);
                if (!(test.a == 1L && test.b == 0L)) {
                    ord *= p;
                }
                ordPrimePower[pk] = ord;
            }
        }

        long total = 0L;
        for (int x = 2; x <= n; ++x) {
            if (x % 2 == 0 || x % 3 == 0)
                continue;

            int t = x;
            long gx = 1L;
            while (t > 1) {
                int p = spf[t];
                int pk = 1;
                while (t % p == 0) {
                    t /= p;
                    pk *= p;
                }
                gx = lcm(gx, ordPrimePower[pk]);
            }
            total += gx;
        }

        return total;
    }

    public static String solve() {
        return Long.toString(G(1000000));
    }

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