public class Euler378 {

    static final int kTargetN = 60000000;
    static final long kMod = 1000000000000000000L;

    static class Fenwick {
        long[] bit;

        Fenwick(int n) {
            bit = new long[n + 1];
        }

        void add(int idx, long val) {
            while (idx < bit.length) {
                bit[idx] += val;
                idx += idx & -idx;
            }
        }

        long sumPrefix(int idx) {
            long s = 0;
            while (idx > 0) {
                s += bit[idx];
                idx -= idx & -idx;
            }
            return s;
        }

        long sumRange(int l, int r) {
            if (r < l)
                return 0;
            return sumPrefix(r) - sumPrefix(l - 1);
        }
    }

    static short[] buildTau(int limit) {
        int[] lp = new int[limit];
        short[] tau = new short[limit];
        byte[] cnt = new byte[limit];
        int[] primes = new int[4000000];
        int primeCount = 0;

        tau[1] = 1;
        for (int i = 2; i < limit; i++) {
            if (lp[i] == 0) {
                lp[i] = i;
                primes[primeCount++] = i;
                tau[i] = 2;
                cnt[i] = 1;
            }

            int lpi = lp[i];
            short tauI = tau[i];
            byte cntI = cnt[i];

            for (int j = 0; j < primeCount; j++) {
                int p = primes[j];
                long x = (long) i * p;
                if (x >= limit)
                    break;

                lp[(int) x] = p;
                if (p == lpi) {
                    cnt[(int) x] = (byte) (cntI + 1);
                    tau[(int) x] = (short) (tauI / (cntI + 1) * (cntI + 2));
                    break;
                } else {
                    cnt[(int) x] = 1;
                    tau[(int) x] = (short) (tauI * 2);
                }
            }
        }
        return tau;
    }

    static int dTriangle(int n, short[] tau) {
        if ((n & 1) == 0) {
            return tau[n / 2] * tau[n + 1];
        }
        return tau[n] * tau[(n + 1) / 2];
    }

    static String solve() {
        short[] tau = buildTau(kTargetN + 2);

        int maxD = 0;
        int[] dtArr = new int[kTargetN + 1];
        for (int i = 1; i <= kTargetN; i++) {
            int d = dTriangle(i, tau);
            dtArr[i] = d;
            if (d > maxD)
                maxD = d;
        }

        int maxRank = maxD + 2;
        Fenwick countFw = new Fenwick(maxRank);
        Fenwick pairFw = new Fenwick(maxRank);

        long answer = 0;
        for (int i = 1; i <= kTargetN; i++) {
            int rank = dtArr[i] + 1;

            long triplesEndingHere = pairFw.sumRange(rank + 1, maxRank);
            answer = (answer + triplesEndingHere) % kMod;

            long greaterLeft = countFw.sumRange(rank + 1, maxRank);
            pairFw.add(rank, greaterLeft);
            countFw.add(rank, 1);
        }

        return Long.toString(answer);
    }

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