#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

constexpr int P = 1e9 + 7;

IL constexpr int qpow (int b, int k = P - 2) {
  int r = 1;
  for (; k; k >>= 1, b = (LL)b * b % P) if (k & 1) r = (LL)r * b % P;
  return r;
}

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

IL int norm (int x) {
  return qm(x), x;
}

constexpr int N = 1e5 + 9;
int n, m, k;
int C[1 << 4][1 << 4];
int pl[N], pr[N];
int ql[N], qr[N], ns[N];

struct BIT {
  int t[N];

  void init () {
    memset(t, 0, (n + 1) << 2);
  }

  void c (int x, int v) {
    for (; x <= n; x += x & -x) {
      qm(t[x] += v - P);
    }
  }

  int q (int x) {
    int s = 0;
    for (; x; x &= x - 1) {
      qm(s += t[x] - P);
    }
    return s;
  }

  int q (int l, int r) {
    return norm(q(r) - q(l - 1));
  }
} s[1 << 4], whq;

vi ad[N], qq[N];

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> k >> m;
  L (i, 0, k) {
    C[i][0] = 1;
    L (j, 1, i) {
      qm(C[i][j] = C[i - 1][j] + C[i - 1][j - 1] - P);
    }
  }
  L (i, 1, n) {
    cin >> pl[i] >> pr[i];
  }
  L (i, 1, m) {
    cin >> ql[i] >> qr[i];
  }
  L (i, 1, n) {
    ad[pr[i]].eb(i);
  }
  L (i, 1, m) {
    qq[qr[i]].eb(i);
  }
  L (i, 1, n) {
    for (int x : qq[i]) {
      L (j, 0, k) {
        ns[x] = (ns[x] + s[j].q(ql[x]) * (LL)qpow(P - ql[x] + 1, k - j) % P * C[k][j]) % P;
      }
    }
    for (int x : ad[i]) {
      L (j, 0, k) {
        int y = qpow(pr[x], j);
        s[j].c(pl[x] + 1, y);
        s[j].c(pr[x] + 1, P - y);
      }
      whq.c(pl[x], qpow(pr[x] - pl[x] + 1, k));
    }
    for (int x : qq[i]) {
      ns[x] = (ns[x] + whq.q(ql[x], n)) % P;
    }
  }
  whq.init();
  L (i, 0, k) {
    s[i].init();
  }
  L (x, 1, n) {
    L (i, 0, k) {
      s[i].c(pl[x], qpow(P - pl[x], i));
    }
    whq.c(pl[x], 1);
  }
  L (i, 1, n) {
    for (int x : qq[i]) {
      ns[x] = (ns[x] + qpow(qr[x] - ql[x] + 1, k) * (LL)whq.q(ql[x] - 1)) % P;
    }
    for (int x : ad[i]) {
      L (j, 0, k) {
        s[j].c(pl[x], P - qpow(P - pl[x], j));
      }
      whq.c(pl[x], P - 1);
    }
    for (int x : qq[i]) {
      ns[x] = (ns[x] + qpow(qr[x] - ql[x] + 1, k) * (LL)whq.q(ql[x], ql[x])) % P;
      L (j, 0, k) {
        ns[x] = (ns[x] + s[j].q(ql[x] + 1, qr[x]) * (LL)qpow(qr[x] + 1, k - j) % P * C[k][j]) % P;
      }
    }
  }
  L (i, 1, m) {
    cout << ns[i] << '\n';
  }
}
// I love WHQ!