import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Euler790 {

    static final long MOD = 50515093L;

    static class Rect {
        int x1, x2, y1, y2;

        Rect(int x1, int x2, int y1, int y2) {
            this.x1 = x1;
            this.x2 = x2;
            this.y1 = y1;
            this.y2 = y2;
        }
    }

    static class Event implements Comparable<Event> {
        int x, y1, y2, delta;

        Event(int x, int y1, int y2, int delta) {
            this.x = x;
            this.y1 = y1;
            this.y2 = y2;
            this.delta = delta;
        }

        @Override
        public int compareTo(Event other) {
            return Integer.compare(this.x, other.x);
        }
    }

    static class SegTree {
        int n;
        long[][] sum;
        int[] lazy;

        SegTree(int[] ys) {
            n = ys.length - 1;
            sum = new long[4 * n + 4][12];
            lazy = new int[4 * n + 4];
            build(1, 0, n - 1, ys);
        }

        void rotateArr(long[] a, int shift) {
            shift %= 12;
            if (shift < 0)
                shift += 12;
            if (shift == 0)
                return;
            long[] b = new long[12];
            for (int i = 0; i < 12; ++i) {
                b[(i + shift) % 12] = a[i];
            }
            System.arraycopy(b, 0, a, 0, 12);
        }

        void apply(int idx, int shift) {
            rotateArr(sum[idx], shift);
            lazy[idx] += shift;
            lazy[idx] %= 12;
            if (lazy[idx] < 0)
                lazy[idx] += 12;
        }

        void pull(int idx) {
            for (int r = 0; r < 12; ++r) {
                sum[idx][r] = sum[idx * 2][r] + sum[idx * 2 + 1][r];
            }
        }

        void push(int idx) {
            if (lazy[idx] != 0) {
                apply(idx * 2, lazy[idx]);
                apply(idx * 2 + 1, lazy[idx]);
                lazy[idx] = 0;
            }
        }

        void build(int idx, int l, int r, int[] ys) {
            if (l == r) {
                long len = (long) ys[l + 1] - (long) ys[l];
                sum[idx][0] = len;
                return;
            }
            int m = (l + r) / 2;
            build(idx * 2, l, m, ys);
            build(idx * 2 + 1, m + 1, r, ys);
            pull(idx);
        }

        void update(int idx, int l, int r, int ql, int qr, int delta) {
            if (ql > r || qr < l)
                return;
            if (ql <= l && r <= qr) {
                apply(idx, delta);
                return;
            }
            push(idx);
            int m = (l + r) / 2;
            update(idx * 2, l, m, ql, qr, delta);
            update(idx * 2 + 1, m + 1, r, ql, qr, delta);
            pull(idx);
        }

        void update(int ql, int qr, int delta) {
            if (ql > qr)
                return;
            update(1, 0, n - 1, ql, qr, delta);
        }

        long[] all() {
            return sum[1];
        }
    }

    static ArrayList<Rect> generateRects(int t) {
        ArrayList<Rect> out = new ArrayList<>(t);
        long s = 290797;

        int[] vals = new int[4 * t];
        vals[0] = (int) s;
        for (int i = 1; i < 4 * t; ++i) {
            s = (s * s) % MOD;
            vals[i] = (int) s;
        }

        for (int i = 0; i < t; ++i) {
            int a = vals[4 * i + 0];
            int b = vals[4 * i + 1];
            int c = vals[4 * i + 2];
            int d = vals[4 * i + 3];

            int x1 = Math.min(a, b);
            int x2 = Math.max(a, b);
            int y1 = Math.min(c, d);
            int y2 = Math.max(c, d);
            out.add(new Rect(x1, x2, y1, y2));
        }
        return out;
    }

    static int binarySearch(int[] arr, int val) {
        int low = 0, high = arr.length;
        while (low < high) {
            int mid = (low + high) / 2;
            if (arr[mid] < val) {
                low = mid + 1;
            } else {
                high = mid;
            }
        }
        return low;
    }

    static long solveT(int t) {
        if (t == 0) {
            return MOD * MOD * 12L;
        }

        ArrayList<Rect> rects = generateRects(t);

        int[] ysRaw = new int[2 * t + 2];
        ysRaw[0] = 0;
        ysRaw[1] = (int) MOD;
        int ysIdx = 2;

        Event[] events = new Event[2 * t];
        int eventsIdx = 0;

        for (Rect r : rects) {
            ysRaw[ysIdx++] = r.y1;
            ysRaw[ysIdx++] = r.y2 + 1;
            events[eventsIdx++] = new Event(r.x1, r.y1, r.y2, 1);
            if (r.x2 + 1 < MOD) {
                events[eventsIdx++] = new Event(r.x2 + 1, r.y1, r.y2, -1);
            }
        }

        Arrays.sort(ysRaw);
        int uniqueCount = 1;
        for (int i = 1; i < ysRaw.length; i++) {
            if (ysRaw[i] != ysRaw[i - 1]) {
                ysRaw[uniqueCount++] = ysRaw[i];
            }
        }
        int[] ys = Arrays.copyOf(ysRaw, uniqueCount);

        Event[] actualEvents = Arrays.copyOf(events, eventsIdx);
        Arrays.sort(actualEvents);

        SegTree seg = new SegTree(ys);

        long[] cnt = new long[12];
        int curX = 0;
        int ei = 0;

        while (ei < actualEvents.length) {
            int nx = actualEvents[ei].x;
            long width = (long) nx - (long) curX;
            if (width > 0) {
                long[] a = seg.all();
                for (int r = 0; r < 12; ++r) {
                    cnt[r] += a[r] * width;
                }
            }

            while (ei < actualEvents.length && actualEvents[ei].x == nx) {
                Event e = actualEvents[ei];
                int l = binarySearch(ys, e.y1);
                int rr = binarySearch(ys, e.y2 + 1) - 1;
                seg.update(l, rr, e.delta);
                ei++;
            }

            curX = nx;
        }

        if (curX < MOD) {
            long width = MOD - (long) curX;
            long[] a = seg.all();
            for (int r = 0; r < 12; ++r) {
                cnt[r] += a[r] * width;
            }
        }

        long ans = 0;
        ans += cnt[0] * 12L;
        for (int r = 1; r <= 11; ++r) {
            ans += cnt[r] * (long) r;
        }

        return ans;
    }

    public static String solve() {
        return Long.toString(solveT(100000));
    }

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