#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define me(f, x) memset(f, x, sizeof(f))
#define mc(f, g) memcpy(f, g, sizeof(g))
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

using uint = unsigned;
using ull = unsigned long long;
using u128 = __uint128_t;

namespace IO {
  char ibuf[1 << 20], *iS, *iT, obuf[1 << 20], *oS = obuf;
#define wrsp(x) wr(x), pc(' ')
#define wrln(x) wr(x), pc('\n')

// Helps
#ifndef LOCAL
#define gh() (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, 1 << 20, stdin), (iS == iT ? EOF : *iS++) : *iS++)
#else
#define gh() getchar()
#endif

  IL void flush () {
    fwrite(obuf, 1, oS - obuf, stdout), oS = obuf;
  }

  struct Flusher {
    ~Flusher () {
      flush();
    }
  } AutoFlush;

  IL void pc (char ch) {
    if (oS == obuf + (1 << 20)) flush(); 
    *oS++ = ch;
  }
//

  IL uint rd () {
    char ch = gh();
    uint x = 0;
    while (ch < '0' || ch > '9') ch = gh();
    while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gh();
    return x;
  }

  char buf[64], *tp = buf;
  template<typename T>
  IL void wr (T x) {
    do {
      *tp++ = x % 10;
      x /= 10;
    } while (x);
    while (tp != buf) {
      pc((*--tp) | 48);
    }
  }
}

using IO::rd;
using IO::wr;
using IO::pc;

constexpr int P = 1e9 + 7;

IL void qm (int &x) {
  x += (x >> 31) & P;
}

IL void ad (int &x, const ull &y) {
  x = (x + y) % P;
}

constexpr int N = 1e4 + 9;
constexpr int M = 205;
constexpr int Q = 1e6 + 9;
int n, m, q, a[N], b[N];
LL ns[Q];

int _f[M];

IL int mod (int x) {
  return x >= m ? x - m : x;
}

struct poly {
  int f[M];

  poly () { me(f, 0); }

  int& at (int x) {
    return f[mod(x)];
  }

  poly operator * (const poly &rhs) const {
    poly s;
    L (i, 0, m - 1) {
      if (int x = f[i]) {
        L (j, 0, m - 1) {
          ad(s.at(i + j), x * (ull)rhs.f[j]);
        }
      }
    }
    return s;
  }

  poly& operator += (const poly &rhs) {
    L (i, 0, m - 1) {
      qm(f[i] += rhs.f[i] - P);
    }
    return *this;
  }

  void upd (int a, int b) {
    mc(_f, f);
    L (i, 0, m - 1) {
      if (int x = f[i]) {
        qm(_f[mod(i + a)] += x - P);
        qm(_f[mod(i + b)] += x - P);
      }
    }
    mc(f, _f);
  }
} pre[N], suf[N], f[N][2], g[N][2], h[N];

vector<tuple<int, int, int, int>> qq[N * 4];

void ins (int l, int r, int o, int x) {
  if (l < 1 || r > n) {
    return;
  }
  int L = 1, R = n, p = 1;
  while (1) {
    int md = (L + R) / 2;
    if (r <= md) {
      R = md;
      p = p * 2;
    } else if (md < l) {
      L = md + 1;
      p = p * 2 + 1;
    } else {
      break;
    }
  }
  qq[p].eb(l, r, o, x);
}

void calc (int l, int r, poly v) {
  if (l == r) {
    h[l] = v;
    return;
  }
  int md = (l + r) >> 1;
  poly v1 = v;
  L (i, l, md) {
    v1.upd(a[i], b[i]);
  }
  poly v2 = v;
  L (i, md + 1, r) {
    v2.upd(a[i], b[i]);
  }
  calc(l, md, v2);
  calc(md + 1, r, v1);
}

void dfs (int l, int r, int p) {
  if (l == r) {
    return;
  }
  int md = (l + r) >> 1;
  dfs(l, md, p * 2);
  dfs(md + 1, r, p * 2 + 1);
  if (qq[p].empty()) {
    return;
  } 
  calc(l, md, pre[l - 1]);
  calc(md + 1, r, suf[r + 1]);
  h[l - 1] = f[l - 1][1];
  L (i, l, md) {
    h[l - 1].upd(a[i], b[i]);
  }
  h[r + 1] = g[r + 1][1];
  L (i, md + 1, r) {
    h[r + 1].upd(a[i], b[i]);
  }
  L (i, l, md) {
    h[i] += h[i - 1];
  }
  R (i, r, md + 1) {
    h[i] += h[i + 1];
  }
  static int k;
  for (auto [x, y, o, i] : qq[p]) {
    u128 s = h[x].f[0] * (ull)h[y].f[0];
    for (k = 1; k + 4 < m; k += 4) {
      s += h[x].f[k + 0] * (ull)h[y].f[m - k - 0];
      s += h[x].f[k + 1] * (ull)h[y].f[m - k - 1];
      s += h[x].f[k + 2] * (ull)h[y].f[m - k - 2];
      s += h[x].f[k + 3] * (ull)h[y].f[m - k - 3];
    }
    while (k < m) {
      s += h[x].f[k] * (ull)h[y].f[m - k];
      ++k;
    }
    ns[i] += o * (int)(s % (uint)P);
  }
}

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  n = rd(), m = rd(), q = rd();
  L (i, 1, n) {
    a[i] = rd(), b[i] = rd();
  }
  pre[0].f[0] = 1;
  suf[n + 1].f[0] = 1;
  L (i, 1, n) {
    (pre[i] = pre[i - 1]).upd(a[i], b[i]);
  }
  R (i, n, 1) {
    (suf[i] = suf[i + 1]).upd(a[i], b[i]);
  }
  f[0][0].f[0] = 1;
  g[n + 1][0].f[0] = 1;
  L (i, 1, n) {
    L (o, 0, 1) {
      (f[i][o] = f[i - 1][o]).upd(a[i], b[i]);
    }
    f[i][1] += f[i - 1][0];
  }
  R (i, n, 1) {
    L (o, 0, 1) {
      (g[i][o] = g[i + 1][o]).upd(a[i], b[i]);
    }
    g[i][1] += g[i + 1][0];
  }
  L (i, 1, q) {
    int l1 = rd(), r1 = rd(), l2 = rd(), r2 = rd();
    ins(r1, l2, 1, i);
    ins(l1 - 1, l2, -1, i);
    ins(r1, r2 + 1, -1, i);
    ins(l1 - 1, r2 + 1, 1, i);
  }
  dfs(1, n, 1);
  L (i, 1, q) {
    ns[i] %= P;
    if (ns[i] < 0) {
      ns[i] += P;
    }
    wrln(ns[i]);
  }
}
// I love WHQ!