#include <bits/stdc++.h>
using namespace std;
unsigned int SA, SB, SC;
int lim;
int n, m;
int ex[10010][105], ey[10010][105];
int getweight()
{
    SA ^= SA << 16;
    SA ^= SA >> 5;
    SA ^= SA << 1;
    unsigned int t = SA;
    SA = SB;
    SB = SC;
    SC ^= t ^ SA;
    return SC % lim + 1;
}
void gen()
{
    scanf("%d%d%u%u%u%d", &n, &m, &SA, &SB, &SC, &lim);
    int i, j, w;

    for (i = 1; i <= n; i++)
        for (j = 1; j <= m; j++)
        {
            w = getweight();
            ex[j][i] = w;
        }

    for (i = 1; i < n; i++)
        for (j = 1; j <= m; j++)
        {
            w = getweight();
            ey[j][i] = w;
        }
}
typedef long long ll;
struct edge
{
    int u, v, w;
    edge(int a, int b, int c) : u(a), v(b), w(c) {}
    bool operator < (const edge B) const {
        return w < B.w;
    }
};
int id(int x, int y)
{
    return (x - 1) * n + y;
}
int key[1000100], f[1000100];
int find(int x)
{
    return f[x] == x ? x : f[x] = find(f[x]);
}
ll kruskal(vector<edge> &a, vector<edge> &b)
{
    ll ans = 0;
    sort(a.begin(), a.end());
    b.clear();

    for (int i = 0; i < a.size(); ++i)
    {
        int fu = find(a[i].u), fv = find(a[i].v);

        if (fu == fv)
            ans += a[i].w;
        else
        {
            if (key[fu] && key[fv])
                f[fu] = fv, b.push_back(edge(fu, fv, a[i].w));
            else if (key[fu])
                f[fv] = fu;
            else
                f[fu] = fv;
        }
    }

    return ans;
}
vector<edge> pre[10010], suf[10010];
ll pres[10010], sufs[10010];
void upt(int x, int op)
{
    f[x] = x;
    key[x] = op;
}
vector<edge> a, b;
void getPre()
{
    a.clear();

    for (int i = 1; i <= n * m; ++i)
        f[i] = i, key[i] = 0;

    for (int i = 1; i <= m; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            upt(id(i, j), 1);
            upt(id(1, j), 1);

            if (i > 2)
                upt(id(i - 1, j), 0);
        }

        for (int j = 1; j <= n; ++j)
        {
            if (i != 1)
            {
                a.push_back(edge(id(i, j), id(i - 1, j), ex[i - 1][j]));
                pres[i] += ex[i - 1][j];
            }

            if (j != n)
            {
                a.push_back(edge(id(i, j), id(i, j + 1), ey[i][j]));
                pres[i] += ey[i][j];
            }
        }

        ll del = kruskal(a, b);
        pres[i] += pres[i - 1] - del;
        pre[i] = b;
        a = b;
    }
}
void getSuf()
{
    a.clear();

    for (int i = 1; i <= n * m; ++i)
        f[i] = i, key[i] = 0;

    for (int i = m; i >= 1; --i)
    {
        for (int j = 1; j <= n; ++j)
        {
            upt(id(i, j), 1);
            upt(id(m, j), 1);

            if (i < m - 1)
                upt(id(i + 1, j), 0);
        }

        for (int j = 1; j <= n; ++j)
        {
            if (i != m)
            {
                a.push_back(edge(id(i, j), id(i + 1, j), ex[i][j]));
                sufs[i] += ex[i][j];
            }

            if (j != n)
            {
                a.push_back(edge(id(i, j), id(i, j + 1), ey[i][j]));
                sufs[i] += ey[i][j];
            }
        }

        ll del = kruskal(a, b);
        sufs[i] += sufs[i + 1] - del;
        suf[i] = b;
        a = b;
    }
}
int l, r, q;
int main()
{
    gen();
    getPre();
    getSuf();
    scanf("%d", &q);

    while (q--)
    {
        a.clear();
        scanf("%d %d", &l, &r);
        ll ans = 0;

        for (int i = 1; i <= n; ++i)
        {
            a.push_back(edge(id(1, i), id(m, i), ex[m][i]));
            upt(id(1, i), 0);
            upt(id(m, i), 0);
            upt(id(l - 1, i), 0);
            upt(id(r + 1, i), 0);
            ans += ex[m][i];
        }

        for (int i = 0; i < pre[l - 1].size(); ++i)
            a.push_back(pre[l - 1][i]);

        for (int i = 0; i < suf[r + 1].size(); ++i)
            a.push_back(suf[r + 1][i]);

        ll del = kruskal(a, b);
        ans += pres[l - 1] + sufs[r + 1] - del;
        printf("%lld\n", ans);
    }

    return 0;
}