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

public class Euler805 {

    static final long MOD = 1000000007L;

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

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

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

    static long modInverse(long a, long mod) {
        long[] res = extendedGcd(a, mod);
        long g = res[0];
        long x = res[1];
        if (g != 1) {
            return 0;
        }
        long v = x % mod;
        if (v < 0) {
            v += mod;
        }
        return v;
    }

    static class PrimeFactorizer {
        int[] spf;

        PrimeFactorizer(int maxN) {
            spf = new int[maxN + 1];
            for (int i = 0; i <= maxN; i++) {
                spf[i] = i;
            }
            if (maxN >= 1) {
                spf[1] = 1;
            }
            for (int i = 2; i * i <= maxN; i++) {
                if (spf[i] == i) {
                    for (int j = i * i; j <= maxN; j += i) {
                        if (spf[j] == j) {
                            spf[j] = i;
                        }
                    }
                }
            }
        }

        long eulerPhi(long n) {
            long result = n;
            long x = n;
            while (x > 1) {
                long p = spf[(int) x];
                while (x % p == 0) {
                    x /= p;
                }
                result -= result / p;
            }
            return result;
        }

        List<Long> primeFactorsWithMultiplicity(long n) {
            List<Long> factors = new ArrayList<>();
            while (n > 1) {
                long p = spf[(int) n];
                factors.add(p);
                n /= p;
            }
            return factors;
        }
    }

    static long multiplicativeOrder(long a, long m, PrimeFactorizer factorizer) {
        if (gcd(a, m) != 1)
            return 0;
        if (m == 1)
            return 1;

        long order = factorizer.eulerPhi(m);
        List<Long> factorsList = factorizer.primeFactorsWithMultiplicity(order);
        HashSet<Long> uniqueFactors = new HashSet<>(factorsList);
        List<Long> factors = new ArrayList<>(uniqueFactors);
        Collections.sort(factors);

        for (long p : factors) {
            while (order % p == 0 && modPow(a, order / p, m) == 1) {
                order /= p;
            }
        }
        return order;
    }

    static long minLMagnitude(long p, long q) {
        long limit = (q + p - 1) / p;
        long pow10 = 1;
        long l = 1;
        while (pow10 < limit) {
            pow10 *= 10;
            l++;
        }
        return l;
    }

    static long solvePair(long u, long v, PrimeFactorizer factorizer) {
        long p = u * u * u;
        long q = v * v * v;
        if (p >= 10 * q)
            return 0;

        long kVal = 10 * q - p;
        long minL = minLMagnitude(p, q);
        long bestL = Long.MAX_VALUE;
        long bestD = 10;

        for (long d = 1; d <= 9; d++) {
            if (p * (d + 1) >= 10 * q)
                continue;
            long g = gcd(kVal, d);
            long mPrime = kVal / g;
            if (gcd(10, mPrime) != 1)
                continue;

            long lBase = multiplicativeOrder(10, mPrime, factorizer);
            if (lBase == 0)
                continue;

            long lCand = ((minL + lBase - 1) / lBase) * lBase;
            if (lCand < bestL || (lCand == bestL && d < bestD)) {
                bestL = lCand;
                bestD = d;
            }
        }

        if (bestL == Long.MAX_VALUE)
            return 0;

        long tenPowL = modPow(10, bestL, MOD);
        long term1 = (bestD % MOD) * (q % MOD) % MOD;
        long term2 = (tenPowL + MOD - 1) % MOD;
        long kInv = modInverse(kVal % MOD, MOD);

        long out = (term1 * term2) % MOD;
        out = (out * kInv) % MOD;
        return out;
    }

    static long computeTotalSerial(int m, PrimeFactorizer factorizer) {
        long total = 0;
        for (long u = 1; u <= m; u++) {
            for (long v = 1; v <= m; v++) {
                if (gcd(u, v) == 1) {
                    total = (total + solvePair(u, v, factorizer)) % MOD;
                }
            }
        }
        return total;
    }

    public static String solve() {
        int m = 200;
        long maxN = 10L * m * m * m;
        PrimeFactorizer factorizer = new PrimeFactorizer((int) maxN);
        return Long.toString(computeTotalSerial(m, factorizer));
    }

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