#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int ll

#define REP(i,n) for(int i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 0
#  define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#  define DBG(fmt, ...)
#endif

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 100010

#define SUBMIT

template< typename T >
class CumulativeSum
{
public:
    CumulativeSum() {}
    CumulativeSum(int sz) : m_Data(sz, T(0)) {};

    void Init(int sz) { m_Data.assign(sz, T(0)); }

    // k に x を加える O(1)
    void Add(int k, T x) {
        assert(static_cast<int>(m_Data.size()) >= k);
        if(static_cast<int>(m_Data.size()) <= k) { m_Data.push_back(x); }
        else { m_Data[k] = (m_Data[k] + x); }
    }

    // 累積和の構築 O(m_Data.size())
    void Build() {
        for(int i = 1; i < static_cast<int>(m_Data.size()); i++) {
            m_Data[i] = (m_Data[i] + m_Data[i - 1]);
        }
    }

    // 区間 [0, k] の和を返す O(1)
    // 閉区間なので k が含まれることに注意
    T Query(int k) {
        if(k < 0) { return T(0); }
        return (m_Data[min(k, static_cast<int>(m_Data.size()) - 1)]);
    }

    // 区間 [l, h] の和を返す O(1)
    // 閉区間なので k が含まれることに注意
    T Query(int l, int h) {
        return (this->Query(h) - this->Query(l-1));
    }
private:
    vector< T > m_Data;
};

// [lb, ub) の範囲で val 以下の要素で最大のもののインデックスを返す
// なければ -1 を返す
// 同じ数が複数ある場合は一番小さいインデックスを返す
static inline ll bin_search4(const vector<ll>& v, ll lb, ll ub, ll val) {
    lb--; ub--;
    while(ub - lb > 1) {
        ll mid = (lb + ub) / 2;
        if(v[mid] >= val) { ub = mid; }
        else { lb = mid; }
    }
    // この時点で lb + 1 = ub
    if(v[ub] <= val) { return ub; }
    if(lb < 0 || v[lb] > val) { return -1; }
    return lb;
}

ll X, K, Q;
vector<ll> R, T, A;

CumulativeSum<ll> cs;   // 区間移動時の差分
// 各時間 R[i] 時の X 以上になってしまってサチる境界値と
// 0 以下になってしまってサチる境界値
// この範囲外のものは、サチッているので以降の砂の量の推移が同じになる
vector<ll> l_bound, u_bound;
// 各時間 R[i] 時の上下でサチっちゃったときのシミュレートした値
vector<ll> l_val, u_val;

// t, a のときの答えを返す
ll func(ll t, ll a) {
    ll ret;
    // 時刻 t の直前の R[i] を探す
    ll pos = bin_search4(R, 0, R.size(), t);
    DBG("t: %lld a: %lld pos: %lld\n", t, a, pos);
    if(pos == -1) {
        // 時刻 0 から愚直にシミュレート
        ret = max(0LL, a - t);
    }
    else {
        DBG("  l_bound: %lld u_bound: %lld\n", l_bound[pos], u_bound[pos]);
        // a がどの範囲になるか確認
        if(l_bound[pos] <= a && a <= u_bound[pos]) {
            DBG("  type 1\n");
            // 一度もサチったことがない
            ret = a + cs.Query(pos);
        }
        else if(a < l_bound[pos]) {
            DBG("  type 2\n");
            // ここに来るまでに下でサチる
            ret = l_val[pos];
        }
        else {
            DBG("  type 3\n");
            // ここに来るまでに上でサチる
            ret = u_val[pos];
        }
        DBG("  ret: %lld\n", ret);
        // R[i] 以降をシミュレート
        if(pos % 2 == 0) { ret += t - R[pos]; }
        else { ret -= t - R[pos]; }
        ret = min(ret, X);
        ret = max(ret, 0LL);
    }
    return ret;
}

vector<ll> solve() {
    vector<ll> ret;
    // 累積和の作成
    cs.Init(K);
    REP(i, K) {
        if(i == 0) {
            cs.Add(i, -R[i]);
            continue;
        }
        if(i % 2 == 0) { cs.Add(i, -(R[i] - R[i-1])); }
        else { cs.Add(i, R[i] - R[i-1]); }
    }
    cs.Build();

    // l_bound, u_bound の作成
    // l_val, u_val の作成
    l_bound.clear();
    u_bound.clear();
    l_val.clear();
    u_val.clear();

    l_bound.resize(K);
    u_bound.resize(K);
    l_val.resize(K);
    u_val.resize(K);

    l_bound[0] = R[0];
    u_bound[0] = X;
    l_val[0] = 0;
    u_val[0] = X - R[0];
    for(ll i = 1; i < K; ++i) {
        ll delta = abs(cs.Query(i, i));
        DBG("i: %lld delta: %lld\n", i, delta);
        if(i % 2 == 0) {
            // 下にいく
            l_bound[i] = l_bound[i-1];
            u_bound[i] = u_bound[i-1];
            l_val[i] = l_val[i-1] - delta;
            if(l_val[i] < 0) { l_bound[i] += abs(l_val[i]); }
            l_val[i] = max(0LL, l_val[i]);
            u_val[i] = u_val[i-1] - delta;
            u_val[i] = max(0LL, u_val[i]);
        }
        else {
            // 上にいく
            l_bound[i] = l_bound[i-1];
            u_bound[i] = u_bound[i-1];
            l_val[i] = l_val[i-1] + delta;
            l_val[i] = min(X, l_val[i]);
            u_val[i] = u_val[i-1] + delta;
            if(u_val[i] > X) { u_bound[i] -= (u_val[i] - X); }
            u_val[i] = min(X, u_val[i]);
        }
        DBG("  l_bound[i]: %lld u_bound[i]: %lld\n", l_bound[i], u_bound[i]);
        DBG("  l_val[i]: %lld u_val[i]: %lld\n", l_val[i], u_val[i]);
    }

    // 答えの作成
    REP(i, Q) { ret.push_back(func(T[i], A[i])); }
    return ret;
}

vector<ll> blute_force() {
    vector<ll> ret;
    REP(i, Q) {
        ll cur = A[i];
        ll j;
        for(j = 0; j < K; ++j) {
            if(T[i] < R[j]) { break; }
            if(j % 2 == 0) { cur -= R[j] - ((j > 0) ? R[j-1] : 0); }
            else { cur += R[j] - ((j > 0) ? R[j-1] : 0); }
            cur = min(cur, X);
            cur = max(cur, 0LL);
        }
        if(j % 2 == 0) { cur -= T[i] - ((j > 0) ? R[j-1] : 0); }
        else { cur += T[i] - ((j > 0) ? R[j-1] : 0); }
        cur = min(cur, X);
        cur = max(cur, 0LL);
        ret.push_back(cur);
    }
    return ret;
}

signed main()
{
#ifdef SUBMIT
    cin >> X >> K;
    R.resize(K);
    REP(i, K) { cin >> R[i]; }
    cin >> Q;
    T.resize(Q);
    A.resize(Q);
    REP(i, Q) { cin >> T[i] >> A[i]; }

    vector<ll> ans = solve();
    REP(i, ans.size()) { printf("%lld\n", ans[i]); }
#else
    random_device r;
    mt19937_64 mt(r());
    uniform_int_distribution<ll> dist(0LL, 50LL);
    uniform_int_distribution<ll> dist2(0LL, 25LL);
    X = 20;
    K = 4;
    Q = 5;
    REP(loop, 100) {
        R.clear();
        T.clear();
        A.clear();
        while(R.size() < K) {
            ll r = dist(mt);
            if(r > 0 && find(R.begin(), R.end(), r) == R.end()) { R.push_back(r); }
        }
        SORT(R);
        while(T.size() < Q) {
            ll t = dist(mt);
            if(find(T.begin(), T.end(), t) == T.end()) {
                T.push_back(t);
                A.push_back(min(X, dist2(mt)));
            }
        }
        vector<ll> ans = blute_force();
        vector<ll> cand = solve();
        if(ans != cand) {
            printf("X: %lld K: %lld Q:%lld\n", X, K, Q);
            printf("R: ");
            for(auto& r : R) { printf("%lld ", r); }
            printf("\nT A:\n");
            REP(i, Q) {
                printf("  %lld %lld\n", T[i], A[i]);
            }
            printf("ans:\n");
            REP(i, ans.size()) { printf("  %lld\n", ans[i]); }
            printf("cand:\n");
            REP(i, cand.size()) { printf("  %lld\n", cand[i]); }
            return 0;
        }
    }
#endif
    return 0;
}


Measured memory_bytes: 8436