#include <cstdio>
#include <algorithm>
#include <iostream>

using namespace std;

__attribute__((always_inline)) void read(int &num) {
        static char inBuffer[0x30D40];

        static unsigned int p = 0x30D3F;
        num = 0x0;

        while(inBuffer[p] < 0x30 | inBuffer[p] > 0x39) {
                ++p != 0x30D40 || (fread(inBuffer, 0x1, 0x30D40, stdin), p = 0x0);
        }

        while(inBuffer[p] > 0x2F & inBuffer[p] < 0x3A) {
                num = num * 0xA + inBuffer[p] - 0x30;

                ++p != 0x30D40 || (fread(inBuffer, 0x1, 0x30D40, stdin), p = 0x0);
        }
}

char outBuffer[0x61A80];
unsigned int p;

__attribute__((always_inline)) void write(unsigned int x) {
        unsigned int digits = x > 0x3B9AC9FF ? 0xA :
                              x > 0x5F5E0FF  ? 0x9 :
                              x > 0x98967F   ? 0x8 :
                              x > 0xF423F    ? 0x7 :
                              x > 0x1869F    ? 0x6 :
                              x > 0x270F     ? 0x5 :
                              x > 0x3E7      ? 0x4 :
                              x > 0x63       ? 0x3 :
                              x > 0x9        ? 0x2 : 0x1;

        for(unsigned int i = ~ -digits; ~i; --i) {
                outBuffer[p + i] = x % 0xA + 0x30;

                x = x / 0xA;
        }

        p = p + digits;
        outBuffer[p++] = 0x20;
}

const int N = 100000 + 7;
int c, n;
int x[N], y[N];
int ty[N];
int w[N], taki = 0;
int ch[N];

int after(int p) {
        int l = 1, r = taki;
        int a = -1;
        while(l <= r) {
                int m = (l + r) / 2;
                if(p <= w[m]) {
                        a = m;
                        r = m - 1;
                } else {
                        l = m + 1;
                }
        }
        return a;
}

int before(int p) {
        int l = 1, r = taki;
        int a = -1;
        while(l <= r) {
                int m = (l + r) / 2;
                if(w[m] <= p) {
                        a = m;
                        l = m + 1;
                } else {
                        r = m - 1;
                }
        }
        return a;
}

struct info {
        int y, i;
};

info a[N];

bool cmp1(info a, info b) {
        return a.y < b.y;
}
bool cmp2(info a, info b) {
        return a.i < b.i;
}

int main() {
        freopen("gropi.in", "r", stdin);
        freopen("gropi.out", "w", stdout);
        read(c);
        read(n);
        for(int i = 1; i <= n; i++) {
                read(x[i]);
                read(a[i].y);
                a[i].i = i;
        }
        sort(a + 1, a + n + 1, cmp1);
        for(int i = 1; i <= n; i++) {
                if(a[i].y != a[i - 1].y)
                        w[++taki] = a[i].y,
                                    a[i].y = taki;
        }
        sort(a + 1, a + n + 1, cmp2);
        for(int i = 1; i <= n; i++) {
                ty[a[i].y] += x[i];
        }
        int rumba = 0;
        for(int i = 1; i <= taki; i++) {
                rumba += (ty[i] != ty[i - 1]);
                ch[i] = rumba;
        }
        int q;
        read(q);
        for(int jj = 1; jj <= q; jj++) {
                int r1, c1, r2, c2;
                read(r1);
                read(c1);
                read(r2);
                read(c2);
                if(c1 > c2) {
                        swap(c1, c2);
                        swap(r1, r2);
                }
                int dst = c2 - c1 + 1;
                int p1 = after(c1 + 1);
                int p2 = before(c2 - 1);
                if(p1 != -1 && p2 != -1 && p1 <= p2) {
                        dst += ch[p2] - ch[p1];
                        dst += (ty[p1] == r1);
                        dst += (ty[p2] == r2);
                } else {
                        dst += (r1 != r2);
                }
                write(dst);
                if(jj != q)
                        outBuffer[p++] = '\n';
        }
        puts(outBuffer);
        return 0;
}