/*
   О НЕТ! ОНИ ДОГОНЯЮТ!!!
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
   🐹🐹🐹🐹🐹🐹🐹🐹🐹🐹
*/

#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <cassert>
#include <unordered_map>
#include <iomanip>
#define set abacaba_set

using namespace std;

typedef long long ll;

mt19937 rnd(228);

const int N = 1e5 + 7;

int t[4 * N];
int set[4 * N];
int add[4 * N];

inline void push(int v)
{
    if (set[v] != -1)
    {
        set[v * 2 + 1] = set[v];
        set[v * 2 + 2] = set[v];
        t[v * 2 + 1] = set[v];
        t[v * 2 + 2] = set[v];
        set[v] = -1;
        add[v] = 0;
    }
    else
    {
        if (set[v * 2 + 1] != -1)
        {
            set[v * 2 + 1] += add[v];
            add[v * 2 + 1] = 0;
            t[v * 2 + 1] += add[v];
        }
        else
        {
            add[v * 2 + 1] += add[v];
            t[v * 2 + 1] += add[v];
        }
        if (set[v * 2 + 2] != -1)
        {
            set[v * 2 + 2] += add[v];
            add[v * 2 + 2] = 0;
            t[v * 2 + 2] += add[v];
        }
        else
        {
            add[v * 2 + 2] += add[v];
            t[v * 2 + 2] += add[v];
        }
        set[v] = -1;
        add[v] = 0;
    }
}

inline void _set(int v, int l, int r, int tl, int tr, int x)
{
    if (tl >= r || tr <= l)
    {
        return;
    }
    if (tl >= l && tr <= r)
    {
        set[v] = x;
        add[v] = 0;
        t[v] = x;
    }
    else
    {
        int tm = (tl + tr) / 2;
        push(v);
        _set(v * 2 + 1, l, r, tl, tm, x);
        _set(v * 2 + 2, l, r, tm, tr, x);
        t[v] = max(t[v * 2 + 1], t[v * 2 + 2]);
    }
}

inline void _add(int v, int l, int r, int tl, int tr, int x)
{
    if (tl >= r || tr <= l)
    {
        return;
    }
    if (tl >= l && tr <= r)
    {
        t[v] += x;
        if (set[v] != -1)
        {
            set[v] += x;
        }
        else
        {
            add[v] += x;
        }
    }
    else
    {
        int tm = (tl + tr) / 2;
        push(v);
        _add(v * 2 + 1, l, r, tl, tm, x);
        _add(v * 2 + 2, l, r, tm, tr, x);
        t[v] = max(t[v * 2 + 1], t[v * 2 + 2]);
    }
}

inline int get(int v, int l, int r, int i)
{
    if (r - l == 1)
    {
        return t[v];
    }
    else
    {
        int m = (l + r) / 2;
        push(v);
        if (i < m) return get(v * 2 + 1, l, m, i);
        else return get(v * 2 + 2, m, r, i);
    }
}

int main()
{
#ifdef ONPC
    freopen("a.in", "r", stdin);
#endif
    int x;
    scanf("%d", &x);
    int k;
    scanf("%d", &k);
    vector <pair <int, int> > e;
    for (int i = 0; i < k; i++)
    {
        int r;
        scanf("%d", &r);
        e.push_back({r, -1});
    }
    int q;
    scanf("%d", &q);
    int n = q;
    vector <pair <pair <int, int>, int> > a;
    for (int i = 0; i < q; i++)
    {
        int t, x;
        scanf("%d%d", &t, &x);
        e.push_back({t, i});
        a.push_back({{x, t}, i});
    }
    sort(e.begin(), e.end());
    sort(a.begin(), a.end());
    vector <int> ind(n), ans(n);
    for (int i = 0; i < n; i++)
    {
        ind[a[i].second] = i;
        _set(0, i, i + 1, 0, n, a[i].first.first);
    }
    int last_time = 0;
    int rev = 0;
    for (auto c : e)
    {
        int need = c.first - last_time;
        if (!rev)
        {
            int l = -1, r = n;
            while (l < r - 1)
            {
                int m = (l + r) / 2;
                if (get(0, 0, n, m) <= need)
                {
                    l = m;
                }
                else
                {
                    r = m;
                }
            }
            if (l != -1)
            {
                _set(0, 0, l + 1, 0, n, 0);
            }
            if (l != n - 1)
            {
                _add(0, l + 1, n, 0, n, -need);
            }
        }
        else
        {
            int l = -1, r = n;
            while (l < r - 1)
            {
                int m = (l + r) / 2;
                if (x - get(0, 0, n, m) >= need)
                {
                    l = m;
                }
                else
                {
                    r = m;
                }
            }
            if (l != -1)
            {
                _add(0, 0, l + 1, 0, n, need);
            }
            if (l != n - 1)
            {
                _set(0, l + 1, n, 0, n, x);
            }
        }
        last_time = c.first;
        if (c.second == -1)
        {
            rev ^= 1;
        }
        else
        {
            ans[c.second] = get(0, 0, n, ind[c.second]);
            /*
            if (rev)
            {
                ans[c.second] = x - ans[c.second];
            }
            */
        }
    }
    for (int i = 0; i < q; i++)
    {
        printf("%d\n", ans[i]);
    }
}


Measured memory_bytes: 9072