import java.util.*;

public class Euler212 {
    static int[] cover;
    static int[] len;

    public static void main(String[] args) {
        int LFG_MOD = 1000000, POS_MOD = 10000, LEN_MOD = 399;
        int N = 50000, needed = 6 * N;
        int[] s = new int[needed + 1];
        for (int k = 1; k <= Math.min(55, needed); k++) {
            long v = 100003L - 200003L * k + 300007L * k * k * k;
            v %= LFG_MOD;
            if (v < 0)
                v += LFG_MOD;
            s[k] = (int) v;
        }
        for (int k = 56; k <= needed; k++)
            s[k] = (s[k - 24] + s[k - 55]) % LFG_MOD;

        int[] x0a = new int[N], x1a = new int[N];
        int[] y0a = new int[N], y1a = new int[N];
        int[] z0a = new int[N], z1a = new int[N];
        int maxX = 0, maxZ = 0;
        for (int i = 0; i < N; i++) {
            int b = 6 * (i + 1);
            x0a[i] = s[b - 5] % POS_MOD;
            y0a[i] = s[b - 4] % POS_MOD;
            z0a[i] = s[b - 3] % POS_MOD;
            int dx = 1 + s[b - 2] % LEN_MOD, dy = 1 + s[b - 1] % LEN_MOD, dz = 1 + s[b] % LEN_MOD;
            x1a[i] = x0a[i] + dx;
            y1a[i] = y0a[i] + dy;
            z1a[i] = z0a[i] + dz;
            maxX = Math.max(maxX, x1a[i]);
            maxZ = Math.max(maxZ, z1a[i]);
        }
        int sz = maxZ + 1;
        cover = new int[4 * sz];
        len = new int[4 * sz];

        // Diff array for cuboid count at each x
        int[] diff = new int[maxX + 1];
        for (int i = 0; i < N; i++) {
            diff[x0a[i]]++;
            diff[x1a[i]]--;
        }
        int[] counts = new int[maxX];
        int act = 0;
        for (int x = 0; x < maxX; x++) {
            act += diff[x];
            counts[x] = act;
        }

        // Build slab lists per x
        int[][] slabY0 = new int[maxX][], slabY1 = new int[maxX][];
        int[][] slabZ0 = new int[maxX][], slabZ1 = new int[maxX][];
        int[] fill = new int[maxX];
        for (int x = 0; x < maxX; x++) {
            slabY0[x] = new int[counts[x]];
            slabY1[x] = new int[counts[x]];
            slabZ0[x] = new int[counts[x]];
            slabZ1[x] = new int[counts[x]];
        }
        for (int i = 0; i < N; i++)
            for (int x = x0a[i]; x < x1a[i]; x++) {
                int f = fill[x];
                slabY0[x][f] = y0a[i];
                slabY1[x][f] = y1a[i];
                slabZ0[x][f] = z0a[i];
                slabZ1[x][f] = z1a[i];
                fill[x]++;
            }

        long total = 0;
        int[][] events = new int[2 * N][4];
        for (int x = 0; x < maxX; x++) {
            int nR = fill[x];
            if (nR == 0)
                continue;
            int ne = 0;
            for (int i = 0; i < nR; i++) {
                events[ne][0] = slabY0[x][i];
                events[ne][1] = slabZ0[x][i];
                events[ne][2] = slabZ1[x][i];
                events[ne][3] = 1;
                ne++;
                events[ne][0] = slabY1[x][i];
                events[ne][1] = slabZ0[x][i];
                events[ne][2] = slabZ1[x][i];
                events[ne][3] = -1;
                ne++;
            }
            Arrays.sort(events, 0, ne, (a, b) -> a[0] - b[0]);
            Arrays.fill(cover, 0);
            Arrays.fill(len, 0);
            long area = 0;
            int prevY = events[0][0], ei = 0;
            while (ei < ne) {
                int y = events[ei][0];
                area += (long) len[1] * (y - prevY);
                while (ei < ne && events[ei][0] == y) {
                    update(1, 0, sz, events[ei][1], events[ei][2], events[ei][3]);
                    ei++;
                }
                prevY = y;
            }
            total += area;
        }
        System.out.println(total);
    }

    static void update(int node, int l, int r, int ql, int qr, int delta) {
        if (qr <= l || r <= ql)
            return;
        if (ql <= l && r <= qr)
            cover[node] += delta;
        else {
            int mid = l + (r - l) / 2;
            update(2 * node, l, mid, ql, qr, delta);
            update(2 * node + 1, mid, r, ql, qr, delta);
        }
        if (cover[node] > 0)
            len[node] = r - l;
        else if (r - l == 1)
            len[node] = 0;
        else
            len[node] = len[2 * node] + len[2 * node + 1];
    }
}