#include <bits/stdc++.h>

constexpr std::array<int, 4> dx{-1, 0, 1, 0}, dy{0, 1, 0, -1};
constexpr int INF = 0x3f3f3f3f;
constexpr int64_t LLINF = 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);
  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);
  }
  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);
  }
  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;
  };
  auto comp = [](int64_t lx, int64_t ly, int64_t rx, int64_t ry) {
    return std::abs(lx - rx) + std::abs(ly - ry);
  };
  std::vector dist(sx, std::vector<int64_t>(sy, LLINF));
  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});
      }
    }
  }
  while ((q--) != 0) {
    int x, y;
    std::cin >> x >> y;
    bool g = true;
    for (int i = 0; i < n; ++i) {
      if (cx.val[a[i]] <= x && x <= cx.val[b[i]] &&
          cy.val[c[i]] <= y && y <= cy.val[d[i]]) {
        g = false;
        break;
      }
    }
    if (!g) {
      std::cout << "-1\n";
      continue;
    }
    std::vector<int> px, py;
    int id = cx.cc(x);
    if (id == sx) {
      px.push_back(id - 1);
    } else if (id == 0 || cx.val[id] == x) {
      px.push_back(id);
    } else {
      px.push_back(id - 1);
      px.push_back(id);
    }
    id = cy.cc(y);
    if (id == sy) {
      py.push_back(id - 1);
    } else if (id == 0 || cy.val[id] == y) {
      py.push_back(id);
    } else {
      py.push_back(id - 1);
      py.push_back(id);
    }
    int64_t ans = LLINF;
    for (int i : px) {
      for (int j : py) {
        ans = std::min(ans, dist[i][j] + comp(cx.val[i], cy.val[j], x, y));
      }
    }
    if (ans == LLINF) {
      std::cout << "-1\n";
    } else {
      std::cout << ans << '\n';
    }
  }
}
constexpr int B = 400;
void solve2(int n, int q) {
  std::vector gr(2 * B + 1, std::vector<bool>(2 * B + 1));
  for (int i = 0; i < n; ++i) {
    int a, b, c, d;
    std::cin >> a >> b >> c >> d;
    for (int j = a; j <= b; ++j) {
      for (int k = c; k <= d; ++k) {
        gr[j + B][k + B] = true;
      }
    }
  }
  std::vector dist(2 * B + 1, std::vector<int>(2 * B + 1, INF));
  dist[B][B] = 0;
  std::vector<int> num(B + 1);
  std::queue<std::pair<int, int>> qq;
  qq.emplace(0, 0);
  while (!qq.empty()) {
    auto [x, y] = qq.front();
    qq.pop();
    ++num[dist[x + B][y + B]];
    if (dist[x + B][y + B] == B) {
      continue;
    }
    for (int d = 0; d < 4; ++d) {
      int nx = x + dx[d];
      int ny = y + dy[d];
      if (nx < -B || nx > B || ny < -B || ny > B || gr[nx + B][ny + B]) {
        continue;
      }
      if (dist[nx + B][ny + B] > dist[x + B][y + B] + 1) {
        dist[nx + B][ny + B] = dist[x + B][y + B] + 1;
        qq.emplace(nx, ny);
      }
    }
  }
  std::partial_sum(num.begin(), num.end(), num.begin());
  while ((q--) != 0) {
    int m;
    std::cin >> m;
    std::cout << num[m] << '\n';
  }
}

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);
  }
}