#include <stdio.h>
#define MAXN 1000000


struct Node {
    Node();
    int val;
    int lazy;
    bool neutralize;
};



void Update(int nod, int st, int dr);
int Query(int nod, int st, int dr);
void Propagate(int nod);



int updatest, updatedr, updateval;
int queryst, querydr;

bool updatemode = 0;


Node arbint[4 * MAXN + 1];

int main() {


    freopen("flag.txt", "r", stdin);

    int n, k;


    scanf("%d%d", &n, &k);


    for(int i = 0; i < k; i++) {
        int x;
        scanf("%d", &x);
        //x++;


        updatest = x;
        updatedr = x;

        updateval = 1;

        Update(1, 1, n);
    }



    int q;

    scanf("%d", &q);


    for(int i = 0; i < q; i++) {
        int x, r;


        scanf("%d%d", &r, &x);
        //x++;
        //y++;

        queryst = x - r;
        querydr = x + r;


        int ans = Query(1, 1, n);

        printf("%d\n", ans);

        updatemode = 1;

        updatest = x - r;
        updatedr = x + r;

        updateval = -ans;


        Update(1, 1, n);



    }






    return 0;
}


void Update(int nod, int st, int dr) {

    Propagate(nod);

    if(updatest <= st && dr <= updatedr) {

        if(updatemode == 0) {
            arbint[nod].lazy += updateval;
        } else {
            arbint[nod].neutralize = 1;
        }

        Propagate(nod);
    } else {
        int mij = (st + dr) / 2;

        if(updatest <= mij) {
            Update(2 * nod, st, mij);
        }

        if(updatedr > mij) {
            Update(2 * nod + 1, mij + 1, dr);
        }

        Propagate(2 * nod);
        Propagate(2 * nod + 1);

        arbint[nod].val = arbint[2 * nod].val + arbint[2 * nod + 1].val;
    }

}


int Query(int nod, int st, int dr) {


    Propagate(nod);

    if(queryst <= st && dr <= querydr) {
        Propagate(nod);
        return arbint[nod].val;
    } else {
        int mij = (st + dr) / 2;

        int ret = 0;

        if(queryst <= mij) {
            ret += Query(2 * nod, st, mij);
        }

        if(querydr > mij) {
            ret += Query(2 * nod + 1, mij + 1, dr);
        }


        return ret;
    }
}

Node::Node() {
    val = 0;
    lazy = 0;
}


void Propagate(int nod) {
    if(arbint[nod].lazy > 0) {
        arbint[nod].val += arbint[nod].lazy;
        arbint[2 * nod].lazy += arbint[nod].lazy;
        arbint[2 * nod + 1].lazy += arbint[nod].lazy;
        arbint[nod].lazy = 0;
    }

    if(arbint[nod].neutralize) {
        arbint[nod].val = 0;
        arbint[2 * nod].neutralize = 1;
        arbint[2 * nod + 1].neutralize = 1;
        arbint[nod].neutralize = 0;
    }
}