import java.util.*;

public class Euler932 {

    static long pow10Int(int e) {
        long v = 1;
        for (int i = 0; i < e; ++i)
            v *= 10;
        return v;
    }

    static List<Integer> sievePrimes(int limit) {
        boolean[] composite = new boolean[limit + 1];
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= limit; ++i) {
            if (!composite[i]) {
                primes.add(i);
                if ((long) i * i <= limit) {
                    for (int j = i * i; j <= limit; j += i) {
                        composite[j] = true;
                    }
                }
            }
        }
        return primes;
    }

    static List<Long> factorPrimePowers(long x, List<Integer> primes) {
        List<Long> parts = new ArrayList<>();
        for (int p : primes) {
            if ((long) p * p > x)
                break;
            if (x % p != 0)
                continue;
            long pk = 1;
            while (x % p == 0) {
                x /= p;
                pk *= p;
            }
            parts.add(pk);
        }
        if (x > 1)
            parts.add(x);
        return parts;
    }

    static long[] egcd(long a, long b) {
        if (b == 0)
            return new long[] { a, 1, 0 };
        long[] g = egcd(b, a % b);
        long x1 = g[1];
        long y1 = g[2];
        return new long[] { g[0], y1, x1 - (a / b) * y1 };
    }

    static long modInv(long a, long mod) {
        long[] g = egcd(a, mod);
        long r = g[1] % mod;
        if (r < 0)
            r += mod;
        return r;
    }

    static class Pair {
        long r, m;

        Pair(long r, long m) {
            this.r = r;
            this.m = m;
        }
    }

    static Pair crtMerge(long r1, long m1, long r2, long m2) {
        if (m1 == 1)
            return new Pair(r2 % m2, m2);
        long inv = modInv(m1 % m2, m2);
        long diff = (r2 - r1) % m2;
        if (diff < 0)
            diff += m2;

        long t = (diff * inv) % m2;
        long mod = m1 * m2;
        long r = (r1 + m1 * t) % mod;
        return new Pair(r, mod);
    }

    static long solveDigits(int nd) {
        long maxN = pow10Int(nd) - 1;
        long sLimit = (long) Math.sqrt(maxN);

        long[] pow10 = new long[nd + 1];
        pow10[0] = 1;
        for (int i = 1; i <= nd; ++i)
            pow10[i] = pow10[i - 1] * 10;

        int sieveLimit = (int) Math.sqrt(pow10[nd - 1] - 1) + 10;
        List<Integer> primes = sievePrimes(sieveLimit);

        Set<Long> seen = new HashSet<>();

        for (int d = 1; d < nd; ++d) {
            long mod = pow10[d] - 1;
            List<Long> primePowers = factorPrimePowers(mod, primes);

            List<Pair> residues = new ArrayList<>();
            residues.add(new Pair(0, 1));

            for (long pk : primePowers) {
                List<Pair> next = new ArrayList<>();
                for (Pair rm : residues) {
                    next.add(crtMerge(rm.r, rm.m, 0, pk));
                    next.add(crtMerge(rm.r, rm.m, 1 % pk, pk));
                }
                residues = next;
            }

            long sMax = Math.min(sLimit, pow10[d] - 1);
            long bLow = d == 1 ? 1 : pow10[d - 1];
            long p10d = pow10[d];

            for (Pair p : residues) {
                long r0 = p.r;
                long step = p.m;
                long s = r0;
                if (s <= 1) {
                    long need = 2 - s;
                    long k = (need + step - 1) / step;
                    if (k > (sMax - s) / step)
                        continue;
                    s += k * step;
                }

                for (; s <= sMax; s += step) {
                    long ssMod = (s % mod) * ((s - 1) % mod) % mod;
                    if (ssMod != 0)
                        continue;

                    long ssDouble = s * (s - 1); // safe because max s limit is 10^8
                    long a = ssDouble / mod;
                    if (a == 0 || a >= s)
                        continue;
                    long b = s - a;

                    if (b < bLow || b >= p10d)
                        continue;

                    long n = s * s;
                    if (n > maxN)
                        continue;
                    if (a * p10d + b != n)
                        continue;

                    seen.add(n);
                }
            }
        }

        long total = 0;
        for (long v : seen) {
            total += v;
        }
        return total;
    }

    public static String solve() {
        return Long.toString(solveDigits(16));
    }

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