#include <bits/stdc++.h>
using namespace std;
const int32_t SZ = 2e5 + 5;
long long int k;
template <typename NODE, typename UPDATE>
struct segtree {
  bool built = false, lazy[4 * SZ];
  NODE zero = NODE(), t[4 * SZ];
  UPDATE noop = UPDATE(), upds[4 * SZ];
  int32_t tl[4 * SZ], tr[4 * SZ];
  inline void pushdown(int32_t v) {
    if (lazy[v]) {
      apply(v * 2, upds[v]);
      apply(v * 2 + 1, upds[v]);
      lazy[v] = 0;
      upds[v] = noop;
    }
  }
  inline void apply(int32_t v, UPDATE &val) {
    if (tl[v] != tr[v]) {
      lazy[v] = 1;
      upds[v].combine(val, tl[v], tr[v]);
    }
    val.apply(t[v], tl[v], tr[v]);
  }
  template <typename T>
  void build(T &a, int32_t v, int32_t l, int32_t r) {
    tl[v] = l;
    tr[v] = r;
    if (l == r) {
      t[v] = a[l];
      if (t[v].v >= ::k) {
        t[v].cnt = 1;
      }
      return;
    } else {
      int32_t tm = (l + r) / 2;
      build(a, v * 2, l, tm);
      build(a, v * 2 + 1, tm + 1, r);
      t[v].merge(t[v * 2], t[v * 2 + 1]);
    }
  }
  NODE query(int32_t v, long long int l, long long int r) {
    if (l > tr[v] || r < tl[v]) return zero;
    if (l <= tl[v] && tr[v] <= r) {
      return t[v];
    }
    pushdown(v);
    NODE a, b, ans;
    a = query(v * 2, l, r);
    b = query(v * 2 + 1, l, r);
    ans.merge(a, b);
    return ans;
  }
  void rupd(int32_t v, long long int l, long long int r, UPDATE &val) {
    if (l > tr[v] || r < tl[v]) return;
    if (l <= tl[v] && tr[v] <= r) {
      apply(v, val);
      return;
    }
    pushdown(v);
    rupd(v * 2, l, r, val);
    rupd(v * 2 + 1, l, r, val);
    t[v].merge(t[v * 2], t[v * 2 + 1]);
  }
  template <typename T>
  long long int descent_right(long long int l, T x, int32_t v, NODE &prev) {
    if (l > tr[v]) return leng;
    if (l <= tl[v]) {
      NODE cur;
      cur.merge(prev, t[v]);
      if (!cur.check(x)) {
        swap(prev, cur);
        return leng;
      }
      if (tl[v] == tr[v]) {
        return tr[v];
      }
    }
    pushdown(v);
    long long int ans = descent_right(l, x, v * 2, prev);
    if (ans != leng) return ans;
    return descent_right(l, x, v * 2 + 1, prev);
  }
  template <typename T>
  long long int descent_left(long long int r, T x, int32_t v, NODE &prev) {
    if (r < tl[v]) return -1;
    if (r >= tr[v]) {
      NODE cur;
      cur.merge(t[v], prev);
      if (!cur.check(x)) {
        swap(cur, prev);
        return -1;
      }
      if (tl[v] == tr[v]) {
        return tl[v];
      }
    }
    pushdown(v);
    long long int ans = descent_left(r, x, v * 2 + 1, prev);
    if (ans != -1) return ans;
    return descent_left(r, x, v * 2, prev);
  }
  long long int leng = SZ;
  void clear() {
    fill(t, t + 4 * leng, zero);
    fill(lazy, lazy + 4 * leng, false);
    fill(upds, upds + 4 * leng, noop);
    built = false;
  }
  template <typename T>
  void build(T &a) {
    build(a, 1, 0, leng - 1);
    built = true;
  }
  template <typename T>
  long long int descent_right(long long int l, T x) {
    NODE prev = zero;
    return descent_right(l, x, 1, prev);
  }
  template <typename T>
  long long int descent_left(long long int r, T x) {
    NODE prev = zero;
    return descent_left(r, x, 1, prev);
  }
  NODE query(long long int l, long long int r) {
    if (!built) build(t);
    return query(1, l, r);
  }
  void rupd(long long int l, long long int r, UPDATE val) {
    if (!built) build(t);
    rupd(1, l, r, val);
  }
};
struct node1 {
  long long int v = 0, cnt = 0;
  node1() {}
  node1(long long int val) { v = val; }
  void merge(node1 &l, node1 &r) {
    v = l.v + r.v;
    cnt = l.cnt + r.cnt;
  }
  bool check(long long int x) { return false; }
};
struct update1 {
  update1() {}
  update1(long long int val) {}
  void combine(update1 &other, int32_t tl, int32_t tr) {}
  void apply(node1 &x, int32_t tl, int32_t tr) {}
};
segtree<node1, update1> s;
const long long int MAXN = 2e5 + 5;
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  long long int n, q, temp, ans = 0;
  cin >> n >> k >> q;
  vector<long long int> a(MAXN, 0);
  for (long long int i = 0; i < n; i++) {
    long long int l, r;
    cin >> l >> r;
    a[l]++;
    a[r + 1]--;
  }
  vector<long long int> p(MAXN, 0);
  p[0] = a[0];
  for (long long int i = 1; i < MAXN; i++) {
    p[i] = a[i] + p[i - 1];
  }
  s.leng = MAXN;
  s.clear();
  s.build(p);
  for (long long int i = 0; i < q; i++) {
    long long int a, b;
    cin >> a >> b;
    cout << s.query(a, b).cnt << endl;
  }
  return 0;
}
