#include <bits/stdc++.h>

constexpr std::array<int, 4> dx{-1, 0, 1, 0}, dy{0, 1, 0, -1};
constexpr int64_t INF = 0x3f3f3f3f3f3f3f3f;

template <class T> struct CC {
  std::vector<T> val;
  void insert(T v) {
    val.push_back(v);
  }
  void init() {
    std::ranges::sort(val);
    val.erase(std::unique(val.begin(), val.end()), val.end());
  }
  int cc(T v) {
    return static_cast<int>(std::lower_bound(val.begin(), val.end(), v) -
                            val.begin());
  }
};

void solve1(int n, int q) {
  CC<int> cx, cy;
  std::vector<int> a(n), b(n), c(n), d(n), x(q), y(q);
  cx.insert(0);
  cy.insert(0);
  for (int i = 0; i < n; ++i) {
    std::cin >> a[i] >> b[i] >> c[i] >> d[i];
    cx.insert(a[i]);
    cx.insert(b[i]);
    cy.insert(c[i]);
    cy.insert(d[i]);
    cx.insert(a[i] - 1);
    cx.insert(b[i] + 1);
    cy.insert(c[i] - 1);
    cy.insert(d[i] + 1);
  }
  for (int i = 0; i < q; ++i) {
    std::cin >> x[i] >> y[i];
    cx.insert(x[i]);
    cy.insert(y[i]);
  }
  cx.init();
  cy.init();
  for (int &i : a) {
    i = cx.cc(i);
  }
  for (int &i : b) {
    i = cx.cc(i);
  }
  for (int &i : c) {
    i = cy.cc(i);
  }
  for (int &i : d) {
    i = cy.cc(i);
  }
  for (int &i : x) {
    i = cx.cc(i);
  }
  for (int &i : y) {
    i = cy.cc(i);
  }
  int sx = static_cast<int>(cx.val.size());
  int sy = static_cast<int>(cy.val.size());
  auto good = [&](int nx, int ny) -> bool {
    if (nx < 0 || nx >= sx || ny < 0 || ny >= sy) {
      return false;
    }
    for (int i = 0; i < n; ++i) {
      if (a[i] <= nx && nx <= b[i] && c[i] <= ny && ny <= d[i]) {
        return false;
      }
    }
    return true;
  };
  std::vector dist(sx, std::vector<int64_t>(sy, INF));
  dist[cx.cc(0)][cy.cc(0)] = 0;
  using T = std::pair<int64_t, std::pair<int, int>>;
  std::priority_queue<T, std::vector<T>, std::greater<>> pq;
  pq.emplace(0, std::pair{cx.cc(0), cy.cc(0)});
  while (!pq.empty()) {
    auto [dd, loc] = pq.top();
    pq.pop();
    auto [lx, ly] = loc;
    if (dd != dist[lx][ly]) {
      continue;
    }
    for (int diff = 0; diff < 4; ++diff) {
      int nx = lx + dx[diff];
      int ny = ly + dy[diff];
      if (!good(nx, ny)) {
        continue;
      }
      int64_t nd = static_cast<int64_t>(std::abs(cx.val[lx] - cx.val[nx])) +
          std::abs(cy.val[ly] - cy.val[ny]);
      if (dist[nx][ny] > dist[lx][ly] + nd) {
        dist[nx][ny] = dist[lx][ly] + nd;
        pq.emplace(dist[nx][ny], std::pair{nx, ny});
      }
    }
  }
  for (int i = 0; i < q; ++i) {
    if (dist[x[i]][y[i]] == INF) {
      std::cout << "-1\n";
    } else {
      std::cout << dist[x[i]][y[i]] << '\n';
    }
  }
}
void solve2(int n, int q) {

}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int n, t, q;
  std::cin >> n >> t >> q;
  if (t == 1) {
    solve1(n, q);
  } else {
    solve2(n, q);
  }
}