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

public class Euler414 {
    static final long MOD = 1000000000000000000L;

    static long powU64(long base, int exp) {
        long r = 1;
        for (int i = 0; i < exp; ++i) {
            r *= base;
        }
        return r;
    }

    static int[] nextState(int p, int q, int b) {
        long b2 = (long) b * b;
        long b4 = b2 * b2;
        long x = (long) p * (b4 - 1L) + (long) q * (b2 - 1L) * (long) b;

        int[] d = new int[5];
        for (int i = 0; i < 5; ++i) {
            d[i] = (int) (x % b);
            x /= b;
        }
        Arrays.sort(d);
        return new int[] { d[4] - d[0], d[3] - d[1] };
    }

    static long ways(int p, int q, int b) {
        long t = 0;
        if (q == 0) {
            if (p == 0) {
                t = 1;
            } else {
                t += 120 / 24 * 2;
                t += 120 / 6 * (p - 1);
            }
        } else if (p == q) {
            t += 120 / 2 / 2 * (p - 1);
            t += 120 / 6 / 2 * 2;
        } else {
            t += 120 / 2 * (q - 1);
            t += 120 / 2 / 2;
            t += 120 / 6;
            t *= 2;

            if (p - 2 >= q) {
                t += 120 / 2 * (p - 1 - q) * 2;
                t += 120 * (p - 1 - q) * (q - 1);
            }
        }
        return (long) (b - p) * t;
    }

    static int dfsDepth(int p, int q, int b, int[][] memo) {
        if (memo[p][q] != -1) {
            return memo[p][q];
        }
        int[] nxt = nextState(p, q, b);
        if (nxt[0] == p && nxt[1] == q) {
            memo[p][q] = 0;
        } else {
            memo[p][q] = dfsDepth(nxt[0], nxt[1], b, memo) + 1;
        }
        return memo[p][q];
    }

    static long sOfBase(int b) {
        long total = powU64(b, 5);
        int[][] memo = new int[b][b];
        for (int i = 0; i < b; i++) {
            Arrays.fill(memo[i], -1);
        }

        long ans = 0;
        for (int p = 1; p < b; ++p) {
            for (int q = 0; q <= p; ++q) {
                long w = ways(p, q, b);
                int d = dfsDepth(p, q, b, memo);

                long wMod = w % MOD;
                long term = 0;
                for (int i = 0; i < d; i++) {
                    term += wMod;
                    if (term >= MOD)
                        term -= MOD;
                }

                ans += term;
                if (ans >= MOD)
                    ans -= MOD;
            }
        }

        long contribution = (total - b - 1) % MOD;
        if (contribution < 0)
            contribution += MOD;
        ans = (ans + contribution) % MOD;
        return ans;
    }

    static String solve() {
        int kFrom = 2;
        int kTo = 300;

        long ans = IntStream.rangeClosed(kFrom, kTo)
                .parallel()
                .mapToLong(k -> {
                    int b = 6 * k + 3;
                    return sOfBase(b);
                })
                .reduce(0, (a, b) -> (a + b) % MOD);

        return Long.toString(ans);
    }

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