/**
 * @file qoj8649-2.cpp
 * @author n685
 * @brief
 * @date 2024-06-11
 *
 *
 */
#include <bits/stdc++.h>

#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbgR(...) 4242
#define dbgP(...) 420
#define dbgRP(...) 420420
void nline() {}
#endif

const int64_t LLINF = static_cast<int64_t>(4e18);
const int LG = 18;

auto solve(int n, int64_t t, std::vector<int> m,
           std::vector<std::vector<std::pair<int64_t, int64_t>>> f, int q,
           std::vector<std::pair<int, int>> qq) -> std::vector<int64_t> {
  for (int i = 0; i < n - 1; ++i) {
    std::sort(f[i].begin(), f[i].end());
    int64_t mi = LLINF;
    for (int j = m[i] - 1; j >= 0; --j) {
      mi = std::min(mi, f[i][j].second);
      f[i][j].second = mi;
    }
  }
  std::vector lift(LG, std::vector<std::vector<int64_t>>(n - 1));
  for (int i = 0; i < n - 1; ++i) {
    lift[0][i].resize(m[i] + 1);
    for (int j = 0; j < m[i]; ++j) {
      lift[0][i][j] = f[i][j].second;
    }
    lift[0][i][m[i]] = t + f[i][0].second;
  }
  for (int i = 1; i < LG; ++i) {
    for (int j = 0; j < n - 1 && j + (1 << i) < n; ++j) {
      lift[i][j].resize(m[j] + 1);
      for (int k = 0; k <= m[j]; ++k) {
        int64_t time = lift[i - 1][j][k];
        int mid = j + (1 << i >> 1);
        int ind = static_cast<int>(
            std::lower_bound(f[mid].begin(), f[mid].end(),
                             std::pair{time % t, static_cast<int64_t>(0)}) -
            f[mid].begin());
        lift[i][j][k] = t * (time / t) + lift[i - 1][mid][ind];
      }
    }
  }
  auto query = [&](int l, int r, int ind) -> int64_t {
    int64_t dist = r - l;
    int64_t st = f[l][ind].first;
    int64_t time = f[l][ind].first;
    for (int i = LG - 1; i >= 0; --i) {
      if (((1 << i) & dist) == 0) {
        continue;
      }
      if (st != time) {
        ind = static_cast<int>(
            std::lower_bound(f[l].begin(), f[l].end(),
                             std::pair{time % t, static_cast<int64_t>(0)}) -
            f[l].begin());
      }
      time = t * (time / t) + lift[i][l][ind];
      int nxt = l + (1 << i);
      l = nxt;
    }
    return time - st;
  };
  std::vector<int64_t> ans(q, LLINF);
  std::set<std::pair<int, int>> s;
  for (int j = 0; j < q; ++j) {
    auto [l, r] = qq[j];
    if (m[l] > m[r - 1] || s.contains({l, r})) {
      continue;
    }
    s.emplace(l, r);
    for (int i = 0; i < m[l]; ++i) {
      ans[j] = std::min(ans[j], query(l, r, i));
    }
  }
  return ans;
}

auto main() -> int {
#ifndef LOCAL
  std::cin.tie(nullptr)->sync_with_stdio(false);
#endif

  int n;
  int64_t t;
  std::cin >> n >> t;

  std::vector<int> m(n);
  std::vector<std::vector<std::pair<int64_t, int64_t>>> f(n - 1);
  for (int i = 0; i < n - 1; ++i) {
    std::cin >> m[i];
    f[i].resize(m[i]);
    for (auto &[a, b] : f[i]) {
      std::cin >> a >> b;
    }
  }
  int q;
  std::cin >> q;
  std::vector<std::pair<int, int>> qq(q);
  for (int i = 0; i < q; ++i) {
    std::cin >> qq[i].first >> qq[i].second;
    --qq[i].first;
    --qq[i].second;
  }
  std::vector<int64_t> a1 = solve(n, t, m, f, q, qq);
  m.pop_back();
  std::reverse(m.begin(), m.end());
  std::reverse(f.begin(), f.end());
  for (int i = 0; i < n - 1; ++i) {
    for (auto &[a, b] : f[i]) {
      a = (t - 1) - a;
      b = (t - 1) - b;
      std::swap(a, b);
    }
  }
  m.push_back(0);
  for (auto &[l, r] : qq) {
    l = (n - 1) - l;
    r = (n - 1) - r;
    std::swap(l, r);
  }
  std::vector<int64_t> a2 = solve(n, t, m, f, q, qq);
  for (int i = 0; i < q; ++i) {
    std::cout << std::min(a1[i], a2[i]) << '\n';
  }
}