#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5;

int tl[N], tr[N], nxt[N], Vnxt[N], pre[N], Vpre[N];
pair<int, int> nd[N];
int Nxt[N][320], BIGNxt[N][320];
long long VNxt[N][320], BIGVNxt[N][320];
int Pre[N][320], BIGPre[N][320];
long long VPre[N][320], BIGVPre[N][320];

signed main() {
    int n, T, tot = 0; scanf("%d%d", &n, &T);
    for (int i = 1, x; i < n; ++i) {
        scanf("%d", &x);
        tl[i] = tot + 1, tr[i] = tot + x;
        for (int j = 1; j <= x; ++j) {
            ++tot;
            scanf("%d%d", &nd[tot].first, &nd[tot].second);
        }
    }
    for (int i = 1; i + 1 < n; ++i) {
        vector< pair< pair<int, int>, int> > o;
        pair<int, int> mn = {T + 1, 0};
        for (int j = tl[i + 1]; j <= tr[i + 1]; ++j) {
            o.push_back({nd[j], j});
            mn = min(mn, {nd[j].second, j});
        }
        sort(o.begin(), o.end());
        vector< pair<int, int> > to;
        for (int j = tl[i]; j <= tr[i]; ++j) {
            to.push_back({nd[j].second, j});
        }
        sort(to.begin(), to.end());
        for (int i = (int)to.size() - 1, j = (int)o.size() - 1, tv = T + 1, wh = 0; ~i; --i) {
            while (~j && o[j].first.first >= to[i].first) {
                if (o[j].first.second < tv) {
                    tv = o[j].first.second, wh = o[j].second;
                }
                --j;
            }
            if (tv <= T) nxt[to[i].second] = wh, Vnxt[to[i].second] = tv - to[i].first;
            else nxt[to[i].second] = mn.second, Vnxt[to[i].second] = T - to[i].first + mn.first;
        }
    }
    for (int i = 1; i + 1 < n; ++i) {
        vector< pair< pair<int, int>, int> > o;
        pair<int, int> mx = {-1, 0};
        for (int j = tl[i]; j <= tr[i]; ++j) {
            o.push_back({{nd[j].second, nd[j].first}, j});
            mx = max(mx, {nd[j].first, j});
        }
        sort(o.rbegin(), o.rend());
        vector< pair<int, int> > to;
        for (int j = tl[i + 1]; j <= tr[i + 1]; ++j) {
            to.push_back({nd[j].first, j});
        }
        sort(to.rbegin(), to.rend());
        for (int i = (int)to.size() - 1, j = (int)o.size() - 1, tv = -1, wh = 0; ~i; --i) {
            while (~j && o[j].first.first <= to[i].first) {
                if (o[j].first.second > tv) {
                    tv = o[j].first.second, wh = o[j].second;
                }
                --j;
            }
            if (tv >= 0) pre[to[i].second] = wh, Vpre[to[i].second] = to[i].first - tv;
            else pre[to[i].second] = mx.second, Vpre[to[i].second] = to[i].first + T - mx.first;
        }
    }
    int sz = sqrt(n) + 1;
    for (int i = 1; i <= tot; ++i) {
        Nxt[i][0] = i;
        for (int j = 1; j <= sz; ++j) {
            Nxt[i][j] = nxt[Nxt[i][j - 1]];
            VNxt[i][j] = VNxt[i][j - 1] + Vnxt[Nxt[i][j - 1]];
        }
        BIGNxt[i][0] = i, BIGNxt[i][1] = Nxt[i][sz], BIGVNxt[i][1] = VNxt[i][sz];
    }
    for (int i = 1; i <= tot; ++i) {
        for (int j = 2; j <= sz; ++j) {
            BIGNxt[i][j] = BIGNxt[BIGNxt[i][j - 1]][1];
            BIGVNxt[i][j] = BIGVNxt[i][j - 1] + BIGVNxt[BIGNxt[i][j - 1]][1];
        }
    }    
    for (int i = tot; i >= 1; --i) {
        Pre[i][0] = i;
        for (int j = 1; j <= sz; ++j) {
            Pre[i][j] = pre[Pre[i][j - 1]];
            VPre[i][j] = VPre[i][j - 1] + Vpre[Pre[i][j - 1]];
        }
        BIGPre[i][0] = i, BIGPre[i][1] = Pre[i][sz], BIGVPre[i][1] = VPre[i][sz];
    }
    for (int i = tot; i >= 1; --i) {
        for (int j = 2; j <= sz; ++j) {
            BIGPre[i][j] = BIGPre[BIGPre[i][j - 1]][1];
            BIGVPre[i][j] = BIGVPre[i][j - 1] + BIGVPre[BIGPre[i][j - 1]][1];
        }
    }
    int q; scanf("%d", &q);
    map< pair<int, int>, long long> M;
    while (q--) {
        int l, r; scanf("%d%d", &l, &r);
        if (M.count({l, r})) {
            printf("%lld\n", M[{l, r}]);
            continue;
        }
        long long res = 1e18;
        int step = r - l - 1;
        if (tr[l] - tl[l] < tr[r - 1] - tl[r - 1]) {
            for (int i = tl[l]; i <= tr[l]; ++i) {
                long long S = nd[i].second - nd[i].first;
                int now = i;
                S += VNxt[now][step % sz] + BIGVNxt[Nxt[now][step % sz]][step / sz];
                res = min(res, S);
            }
        } else {
            for (int i = tl[r - 1]; i <= tr[r - 1]; ++i) {
                long long S = nd[i].second - nd[i].first;
                int now = i;
                S += VPre[now][step % sz] + BIGVPre[Pre[now][step % sz]][step / sz];
                res = min(res, S);
            }
        }
        printf("%lld\n", M[{l, r}] = res);
    }
    return 0;
}