#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
  return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
  return x * x;
}
template <typename T>
inline string toStr(T x) {
  stringstream st;
  st << x;
  string s;
  st >> s;
  return s;
}
template <typename T>
inline int bit(T mask, int b) {
  return (b >= 0 && (mask & (T(1) << b)) != 0) ? 1 : 0;
}
inline int nextInt() {
  int x;
  if (scanf("%d", &x) != 1) throw;
  return x;
}
inline long long nextInt64() {
  long long x;
  if (scanf("%lld", &x) != 1) throw;
  return x;
}
inline double nextDouble() {
  double x;
  if (scanf("%lf", &x) != 1) throw;
  return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int OSN = (1 << 17) - 1;
const int MAXN = 300100;
struct point {
  int x, y;
  void rotate() { swap(x, y); }
};
struct rect {
  point minp;
  point maxp;
  void rotate() {
    minp.rotate();
    maxp.rotate();
  }
};
vector<int> rs[MAXN], rf[MAXN], p[MAXN];
pair<int, int> tree[2 * OSN + 100];
set<pair<int, int> > lst[MAXN];
int W, H, n, m;
vector<bool> ans, ANS[2];
point a[MAXN];
rect b[MAXN];
void go(int id) {
  int v = id + OSN;
  if (lst[id].empty()) {
    tree[v] = make_pair(INF, -1);
  } else {
    tree[v] = *lst[id].begin();
  }
  v = (v - 1) / 2;
  while (v > 0) {
    tree[v] = min(tree[2 * v + 1], tree[2 * v + 2]);
    v = (v - 1) / 2;
  }
}
void add(const rect& r, int id) {
  int ly = r.minp.y, ry = r.maxp.y;
  lst[ly].insert(make_pair(ry, id));
  go(ly);
}
void remove(const rect& r, int id) {
  int ly = r.minp.y, ry = r.maxp.y;
  lst[ly].erase(make_pair(ry, id));
  go(ly);
}
pair<int, int> getMin(int v, int l, int r, int ll, int rr) {
  if (l > rr || ll > r || ll > rr) return make_pair(INF, -1);
  if (ll <= l && r <= rr) return tree[v];
  int mid = (l + r) >> 1;
  return min(getMin(2 * v + 1, l, mid, ll, rr),
             getMin(2 * v + 2, mid + 1, r, ll, rr));
}
void check(int l, int r) {
  while (true) {
    pair<int, int> value = getMin(0, 0, OSN, l, r);
    if (value.first > r) {
      return;
    }
    int id = value.second;
    remove(b[id], id);
    ans[id] = false;
  }
}
void clear() {
  memset(tree, 60, sizeof tree);
  for (int i = 0; i < (int)(max(W, H) + 1); i++) {
    lst[i].clear();
    rs[i].clear();
    rf[i].clear();
    p[i].clear();
  }
}
void solve() {
  for (int i = 0; i < (int)(m); i++) {
    rf[b[i].maxp.x + 1].push_back(i);
    rs[b[i].minp.x].push_back(i);
  }
  for (int i = 0; i < (int)(n); i++) {
    p[a[i].x].push_back(a[i].y);
  }
  for (int x = 0; x < (int)(W); x++) {
    for (int i = 0; i < (int)(rf[x].size()); i++) {
      int id = rf[x][i];
      remove(b[id], id);
    }
    for (int i = 0; i < (int)(rs[x].size()); i++) {
      int id = rs[x][i];
      add(b[id], id);
    }
    if (!p[x].empty()) {
      sort((p[x]).begin(), (p[x]).end());
      check(0, p[x][0] - 1);
      check(p[x].back() + 1, H - 1);
      for (int i = 0; i < (int)(p[x].size() - 1); i++) {
        check(p[x][i] + 1, p[x][i + 1] - 1);
      }
    } else {
      check(0, H - 1);
    }
  }
}
void rotate() {
  swap(W, H);
  for (int i = 0; i < (int)(n); i++) {
    a[i].rotate();
  }
  for (int i = 0; i < (int)(m); i++) {
    b[i].rotate();
  }
}
int main() {
  cout.setf(ios::fixed);
  cout.precision(10);
  double _startTime = clock();
  W = nextInt();
  H = nextInt();
  n = nextInt();
  m = nextInt();
  for (int i = 0; i < (int)(n); i++) {
    a[i].x = nextInt() - 1;
    a[i].y = nextInt() - 1;
  }
  for (int i = 0; i < (int)(m); i++) {
    b[i].minp.x = nextInt() - 1;
    b[i].minp.y = nextInt() - 1;
    b[i].maxp.x = nextInt() - 1;
    b[i].maxp.y = nextInt() - 1;
  }
  for (int step = 0; step < (int)(2); step++) {
    ans = vector<bool>(MAXN, true);
    clear();
    solve();
    ANS[step] = ans;
    rotate();
  }
  for (int i = 0; i < (int)(m); i++) {
    if (ANS[0][i] || ANS[1][i]) {
      puts("YES");
    } else {
      puts("NO");
    }
  }
  cerr << "Elapsed " << (clock() - _startTime) / CLOCKS_PER_SEC << " s" << endl;
  return 0;
}
