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

public class Euler453 {
    static final long MOD = 135707531;

    static long modPow(long base, long exp) {
        long res = 1;
        long cur = base % MOD;
        while (exp > 0) {
            if ((exp & 1) != 0)
                res = (res * cur) % MOD;
            cur = (cur * cur) % MOD;
            exp >>= 1;
        }
        return res;
    }

    static long modInv(long x) {
        return modPow(x, MOD - 2);
    }

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

    static class ModStats {
        long c3 = 0, c4 = 0, sumg = 0, sumArea2 = 0;
    }

    public static String solve() {
        int m = 12345;
        int n = 6789;

        int maxG = Math.max(m, n);
        long[] gMod = new long[maxG + 1];
        long[] g1Mod = new long[maxG + 1];
        long[] g2Mod = new long[maxG + 1];
        long[] comb2Mod = new long[maxG + 1];

        for (int g = 0; g <= maxG; g++) {
            gMod[g] = g % MOD;
            g1Mod[g] = (g >= 1) ? (g - 1) % MOD : 0;
            g2Mod[g] = (gMod[g] * gMod[g]) % MOD;
            if (g >= 2) {
                long comb = (long) (g - 1) * (g - 2) / 2;
                comb2Mod[g] = comb % MOD;
            }
        }

        long[] mxMod = new long[m + 1];
        long[] nyMod = new long[n + 1];
        long[] dx2Mod = new long[m + 1];
        long[] dy2Mod = new long[n + 1];

        for (int dx = 0; dx <= m; dx++) {
            mxMod[dx] = (m + 1 - dx) % MOD;
            dx2Mod[dx] = ((long) dx * dx) % MOD;
        }
        for (int dy = 0; dy <= n; dy++) {
            nyMod[dy] = (n + 1 - dy) % MOD;
            dy2Mod[dy] = ((long) dy * dy) % MOD;
        }

        ModStats total = new ModStats();
        long nPlus1Mod = (n + 1) % MOD;
        long mPlus1Mod = (m + 1) % MOD;

        for (int dx = 1; dx <= m; dx++) {
            int g = dx;
            long pairs = (nPlus1Mod * mxMod[dx]) % MOD;
            total.sumg = (total.sumg + pairs * gMod[g]) % MOD;
            if (g >= 2)
                total.c3 = (total.c3 + pairs * g1Mod[g]) % MOD;
            if (g >= 3)
                total.c4 = (total.c4 + pairs * comb2Mod[g]) % MOD;
        }

        for (int dy = 1; dy <= n; dy++) {
            int g = dy;
            long pairs = (mPlus1Mod * nyMod[dy]) % MOD;
            total.sumg = (total.sumg + pairs * gMod[g]) % MOD;
            if (g >= 2)
                total.c3 = (total.c3 + pairs * g1Mod[g]) % MOD;
            if (g >= 3)
                total.c4 = (total.c4 + pairs * comb2Mod[g]) % MOD;
        }

        int threads = Math.max(1, Runtime.getRuntime().availableProcessors());
        int chunkSize = m / threads;
        if (chunkSize == 0)
            chunkSize = 1;

        List<int[]> chunks = new ArrayList<>();
        for (int startDx = 1; startDx <= m; startDx += chunkSize) {
            chunks.add(new int[] { startDx, Math.min(m, startDx + chunkSize - 1) });
        }

        long[] sumRes = new long[4];

        chunks.parallelStream().forEach(chunk -> {
            int startDx = chunk[0];
            int endDx = chunk[1];

            long localC3 = 0, localC4 = 0, localSumg = 0, localSumArea2 = 0;

            for (int dx = startDx; dx <= endDx; dx++) {
                long mx = mxMod[dx];
                long dx2 = dx2Mod[dx];
                for (int dy = 1; dy <= n; dy++) {
                    int g = gcd(dx, dy);
                    long w = (mx * nyMod[dy]) % MOD;
                    long pairs = (w * 2) % MOD;

                    localSumg = (localSumg + pairs * gMod[g]) % MOD;
                    if (g >= 2)
                        localC3 = (localC3 + pairs * g1Mod[g]) % MOD;
                    if (g >= 3)
                        localC4 = (localC4 + pairs * comb2Mod[g]) % MOD;

                    long dy2 = dy2Mod[dy];
                    long term = (dx2 + dy2) % MOD;
                    term = (term + 11 * dx2 % MOD * dy2) % MOD;
                    term = (term - g2Mod[g] + MOD) % MOD;

                    localSumArea2 = (localSumArea2 + w * term) % MOD;
                }
            }

            synchronized (sumRes) {
                sumRes[0] = (sumRes[0] + localC3) % MOD;
                sumRes[1] = (sumRes[1] + localC4) % MOD;
                sumRes[2] = (sumRes[2] + localSumg) % MOD;
                sumRes[3] = (sumRes[3] + localSumArea2) % MOD;
            }
        });

        total.c3 = (total.c3 + sumRes[0]) % MOD;
        total.c4 = (total.c4 + sumRes[1]) % MOD;
        total.sumg = (total.sumg + sumRes[2]) % MOD;
        total.sumArea2 = (total.sumArea2 + sumRes[3]) % MOD;

        total.sumArea2 = (total.sumArea2 * modInv(3)) % MOD;

        long bigN = (mPlus1Mod * nPlus1Mod) % MOD;
        long C2 = bigN * (bigN - 1) % MOD * modInv(2) % MOD;
        long C3n = bigN * (bigN - 1) % MOD * (bigN - 2 + MOD) % MOD * modInv(6) % MOD;
        long C4n = bigN * (bigN - 1) % MOD * (bigN - 2 + MOD) % MOD * (bigN - 3 + MOD) % MOD * modInv(24) % MOD;

        long SColl = ((bigN - 3 + MOD) % MOD * total.c3 % MOD - 3 * total.c4 % MOD + MOD) % MOD;

        long lineSum = (2 * C2 + 6 * total.c3 + 4 * total.c4) % MOD;
        long sumB = (bigN * total.sumg % MOD - lineSum + MOD) % MOD;

        long ans = C4n;
        ans = (ans - SColl + MOD) % MOD;
        ans = (ans + 2 * C3n) % MOD;
        ans = (ans - 2 * total.c3 % MOD + MOD) % MOD;
        ans = (ans + total.sumArea2) % MOD;
        ans = (ans - sumB + MOD) % MOD;

        return Long.toString(ans);
    }

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