/* ---------- STL Libraries ---------- */

// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>

// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
#include <random>

// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>

/* ---------- Namespace ---------- */

using namespace std;

/* ---------- Type Abbreviation ---------- */

template <typename T>
using PQ = priority_queue<T>;
template <typename T>
using GPQ = priority_queue<T, vector<T>, greater<T>>;

using ll = long long;

#define fst first
#define snd second
#define mp make_pair
#define mt make_tuple

/* ---------- conversion ---------- */

#define INT(c) static_cast<int>(c)
#define CHAR(n) static_cast<char>(n)
#define LL(n) static_cast<ll>(n)
#define DOUBLE(n) static_cast<double>(n)

/* ---------- container ---------- */

#define ALL(v) (v).begin(), (v).end()
#define SIZE(v) (LL((v).size()))

#define FIND(v, k) (v).find(k) != (v).end()
#define VFIND(v, k) find(ALL(v), k) != (v).end()

#define gsort(b, e) sort(b, e, greater<decltype(*b)>())

/* ----------- debug ---------- */

template <class T>
ostream& operator<<(ostream& os, vector<T> v) {
    os << "[";
    for (auto vv : v)
        os << vv << ",";
    return os << "]";
}

template <class T>
ostream& operator<<(ostream& os, set<T> v) {
    os << "[";
    for (auto vv : v)
        os << vv << ",";
    return os << "]";
}

template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> p) {
    return os << "(" << p.fst << "," << p.snd << ")";
}

/* ---------- Constants ---------- */

// const ll MOD = 1e9 + 7;
// const int INF = 1 << 25;
// const ll INF = 1LL << 50;
// const double PI = acos(-1);
// const double EPS = 1e-10;
// mt19937 mert(LL(time(0)));

/* ---------- Short Functions ---------- */

template <typename T>
T sq(T a) {
    return a * a;
}

template <typename T>
T gcd(T a, T b) {
    if (a > b) return gcd(b, a);
    return a == 0 ? b : gcd(b % a, a);
}

template <typename T, typename U>
T mypow(T b, U n) {
    if (n == 0) return 1;
    if (n == 1) return b /* % MOD */;
    if (n % 2 == 0) {
        return mypow(b * b /* % MOD */, n / 2);
    } else {
        return mypow(b, n - 1) * b /* % MOD */;
    }
}

ll pcnt(ll b) {
    return __builtin_popcountll(b);
}

/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */

int main() {
    ll X;
    int K;
    cin >> X >> K;

    ll r[K + 1];
    r[0] = 0;
    for (int i = 1; i <= K; ++i) {
        cin >> r[i];
    }

    pair<ll, ll> l[K + 1], u[K + 1];
    // l[i] = (潰されないaの下限値,
    //         a=下限値の場合, 時刻r[i]にてAに入っている砂の量)
    // rは上限

    l[0] = mp(0LL, 0LL);
    u[0] = mp(X, X);

    for (int i = 1; i <= K; ++i) {
        if (i % 2 > 0) {
            // A->Bへ砂が移る
            ll s = u[i - 1].second - (r[i] - r[i - 1]);
            if (s >= 0) {
                u[i] = mp(u[i - 1].first, s);
            } else {
                // aがどれだけ小さくても潰れる
                u[i] = mp(0, 0);
                l[i] = mp(0, 0);
                continue;
            }

            s = l[i - 1].second - (r[i] - r[i - 1]);
            if (s >= 0) {
                l[i] = mp(l[i - 1].first, s);
            } else {
                l[i] = mp(l[i - 1].first - s, 0);
            }
        } else {
            // B->Aへ砂が移る
            ll s = l[i - 1].second + (r[i] - r[i - 1]);
            if (s <= X) {
                l[i] = mp(l[i - 1].first, s);
            } else {
                // aがどれだけ大きくても潰れる
                l[i] = mp(X, X);
                u[i] = mp(X, X);
                continue;
            }

            s = u[i - 1].second + (r[i] - r[i - 1]);
            if (s <= X) {
                u[i] = mp(u[i - 1].first, s);
            } else {
                u[i] = mp(u[i - 1].first - (s - X), X);
            }
        }
    }

    int Q;
    cin >> Q;
    for (int q = 0; q < Q; ++q) {
        ll t, a;
        cin >> t >> a;

        // r[i] <= tなる最大のiを探る
        int ok = 0, ng = K + 1;
        while (ng - ok > 1) {
            int mid = (ok + ng) / 2;
            if (r[mid] <= t) {
                ok = mid;
            } else {
                ng = mid;
            }
        }

        // 時刻r[i]における砂の量を求める
        ll s = 0;
        if (a < l[ok].first) {
            s = l[ok].second;
        } else if (a > u[ok].first) {
            s = u[ok].second;
        } else {
            s = a - l[ok].first + l[ok].second;
        }

        // 時刻tにおける砂の量を限度無視で求める
        if (ok % 2 == 0) {
            s -= t - r[ok];
        } else {
            s += t - r[ok];
        }

        cout << max(0LL, min(s, X)) << endl;
    }
    return 0;
}


Measured memory_bytes: 5120