#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))

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

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);
    if(pos == -1) {
        // 時刻 0 から愚直にシミュレート
        ret = max(0LL, a - t);
    }
    else {
        // a がどの範囲になるか確認
        if(l_bound[pos] <= a && a <= u_bound[pos]) {
            // 一度もサチったことがない
            ret = a + cs.Query(pos);
        }
        else if(a < l_bound[pos]) {
            // ここに来るまでに下でサチる
            ret = l_val[pos];
        }
        else {
            // ここに来るまでに上でサチる
            ret = u_val[pos];
        }
        // 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.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));
        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]);
        }
    }

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

signed main()
{
    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]); }
    return 0;
}


Measured memory_bytes: 8436