import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class Euler417 {
    static long modPow(long base, long exp, long mod) {
        long result = 1 % mod;
        long cur = base % mod;
        long e = exp;
        while (e > 0) {
            if ((e & 1) != 0) {
                result = (result * cur) % mod;
            }
            cur = (cur * cur) % mod;
            e >>= 1;
        }
        return result;
    }

    static short[] buildOddSpf(int limit) {
        short[] spf = new short[limit / 2 + 1];
        int root = (int) Math.sqrt(limit);

        for (int i = 3; i <= root; i += 2) {
            if (spf[i >> 1] != 0)
                continue;
            int step = 2 * i;
            for (long j = (long) i * i; j <= limit; j += step) {
                if (spf[(int) (j >> 1)] == 0) {
                    spf[(int) (j >> 1)] = (short) i;
                }
            }
        }
        return spf;
    }

    static int[] collectPrimes(int limit, short[] spf) {
        int[] primes = new int[limit / 12 + 1000];
        int count = 0;
        for (int p = 3; p <= limit; p += 2) {
            if (p != 5 && spf[p >> 1] == 0) {
                if (count == primes.length) {
                    primes = Arrays.copyOf(primes, primes.length * 2);
                }
                primes[count++] = p;
            }
        }
        return Arrays.copyOf(primes, count);
    }

    static int multiplicativeOrderPrime(int p, short[] spf) {
        int ord = p - 1;
        int rem = ord;

        if ((rem & 1) == 0) {
            while ((rem & 1) == 0)
                rem >>= 1;
            while ((ord & 1) == 0) {
                int cand = ord >> 1;
                if (modPow(10, cand, p) == 1) {
                    ord = cand;
                } else {
                    break;
                }
            }
        }

        while (rem > 1) {
            int q = spf[rem >> 1];
            if (q == 0)
                q = rem;
            while (rem % q == 0)
                rem /= q;
            while (ord % q == 0) {
                int cand = ord / q;
                if (modPow(10, cand, p) == 1) {
                    ord = cand;
                } else {
                    break;
                }
            }
        }
        return ord;
    }

    static int[][] buildSmallPrimePowerOrders(int limit, int[] primes, int[] ordPrime) {
        int root = (int) Math.sqrt(limit);
        int[][] primePowerOrders = new int[root + 1][];

        for (int p : primes) {
            if (p > root)
                break;
            int emax = 1;
            long pp = p;
            while (pp <= limit / p) {
                pp *= p;
                emax++;
            }

            int[] table = new int[emax + 1];
            table[1] = ordPrime[p >> 1];

            pp = p;
            for (int e = 2; e <= emax; e++) {
                pp *= p;
                int prev = table[e - 1];
                int cur = prev;
                if (modPow(10, prev, pp) != 1) {
                    cur = prev * p;
                }
                table[e] = cur;
            }
            primePowerOrders[p] = table;
        }
        return primePowerOrders;
    }

    static int[] buildSmoothNumbers(int limit) {
        int[] temp = new int[2000];
        int count = 0;
        for (long p2 = 1; p2 <= limit; p2 *= 2) {
            for (long p5 = 1; p2 * p5 <= limit; p5 *= 5) {
                temp[count++] = (int) (p2 * p5);
            }
        }
        int[] res = Arrays.copyOf(temp, count);
        Arrays.sort(res);
        return res;
    }

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

    static int multiplicativeOrderFromFactorization(int n, short[] spf, int[] ordPrime, int[][] primePowerOrders) {
        int ord = 1;
        int x = n;
        while (x > 1) {
            int p = spf[x >> 1];
            if (p == 0)
                p = x;
            int e = 1;
            int pp = p;
            x /= p;
            while (x % p == 0) {
                x /= p;
                pp *= p;
                e++;
            }

            int part = 0;
            if (e == 1) {
                part = ordPrime[p >> 1];
            } else if (p < primePowerOrders.length && primePowerOrders[p] != null && e < primePowerOrders[p].length) {
                part = primePowerOrders[p][e];
            } else {
                part = ordPrime[p >> 1];
                long mod = p;
                for (int k = 2; k <= e; k++) {
                    mod *= p;
                    if (modPow(10, part, mod) != 1) {
                        part *= p;
                    }
                }
            }

            long g = gcd(ord, part);
            ord = (int) (((long) ord / g) * part);
        }
        return ord;
    }

    static String solve() {
        int limit = 100000000;
        short[] spf = buildOddSpf(limit);
        int[] primes = collectPrimes(limit, spf);

        int[] ordPrime = new int[limit / 2 + 1];
        ordPrime[0] = 1;

        IntStream.range(0, primes.length).parallel().forEach(i -> {
            int p = primes[i];
            ordPrime[p >> 1] = multiplicativeOrderPrime(p, spf);
        });

        int[][] primePowerOrders = buildSmallPrimePowerOrders(limit, primes, ordPrime);
        int[] smooth = buildSmoothNumbers(limit);

        int oddCount = (limit - 3) / 2 + 1;

        long total = IntStream.range(0, oddCount).parallel().mapToLong(idx -> {
            int n = 3 + 2 * idx;
            if (n % 5 == 0)
                return 0;

            int ord = multiplicativeOrderFromFactorization(n, spf, ordPrime, primePowerOrders);
            int quotient = limit / n;

            int low = 0, high = smooth.length;
            while (low < high) {
                int mid = (low + high) >>> 1;
                if (smooth[mid] <= quotient) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }
            int multiplicity = low;

            return (long) ord * multiplicity;
        }).sum();

        return Long.toString(total);
    }

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