Problem:
Score : 700 points

Problem Statement

We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand.
When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.

The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second.
When the upper bulb no longer contains any sand, nothing happens.

Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).

We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.

You are given Q queries.
Each query is in the form of (t_i,a_i).
For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.

Constraints

1≤X≤10^9

1≤K≤10^5

1≤r_1<r_2< .. <r_K≤10^9

1≤Q≤10^5

0≤t_1<t_2< .. <t_Q≤10^9

0≤a_i≤X (1≤i≤Q)

All input values are integers.

Input

The input is given from Standard Input in the following format:

X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q

Output

For each query, print the answer in its own line.

Sample Input 1

180
3
60 120 180
3
30 90
61 1
180 180

Sample Output 1

60
1
120

In the first query, 30 out of the initial 90 grams of sand will drop from bulb A, resulting in 60 grams.
In the second query, the initial 1 gram of sand will drop from bulb A, and nothing will happen for the next 59 seconds. Then, we will turn over the sandglass, and 1 second after this, bulb A contains 1 gram of sand at the time in question.

Sample Input 2

100
1
100000
4
0 100
90 100
100 100
101 100

Sample Output 2

100
10
0
0

In every query, the upper bulb initially contains 100 grams, and the question in time comes before we turn over the sandglass.

Sample Input 3

100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10

Sample Output 3

19
52
91
10
58
42
100

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <cctype>
#include <ctime>
#include <climits>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <tuple>
#include <cmath>
#include <algorithm>
#include <unordered_set>
#include <unordered_map>

using namespace std;

#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif

#define mp make_pair
#define mt make_tuple
#define fr first
#define sc second
#define pb push_back
#define pp pop_back
#define all(x) x.begin(), x.end()

#define int long long

typedef long long ll;
typedef long double ld;
typedef tuple<long long, long long, long long> tlll;
typedef tuple<int, int, int> tiii;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;

const int INF = 2000000007;
const int SZ = 3e5;
int ar[SZ];
int res[SZ];
int x;

struct node
{
    bool ok = false;
    int l, r, add, sval;
    node *left, *right;
};

node *build(int l, int r)
{
    node *res = new node;
    res->l = l;
    res->r = r;
    res->add = res->sval = 0;
    if (l == r)
    {
        res->sval = ar[l];
        res->ok = true;
    }
    else
    {
        int mid = (l + r) / 2;
        res->left = build(l, mid);
        res->right = build(mid + 1, r);
    }
    return res;
}

void push(node *root)
{
    if (!root->left)
        return;
    if (!root->ok)
    {
        root->left->add += root->add;
        root->right->add += root->add;
        root->add = 0;
    }
    else
    {
        root->left->sval = root->right->sval = root->sval;
        root->left->ok = root->right->ok = true;
        root->left->add = root->right->add = root->add;
        root->sval = root->add = 0;
        root->ok = false;
    }
}

int query(node *root, int i)
{
    if (i < root->l || i > root->r) return 0;
    if (root->l == root->r) return root->sval + root->add;
    push(root);
    return query(root->left, i) + query(root->right, i);
}

void add(node *root, int l, int r, int d)
{
    if (l > root->r || r < root->l) return;
    if (l <= root->l && r >= root->r)
    {
        root->add += d;
        return;
    }
    push(root);
    add(root->left, l, r, d);
    add(root->right, l, r, d);
}

void stroot(node *root, int l, int r, int d)
{
    if (l > root->r || r < root->l) return;
    if (l <= root->l && r >= root->r)
    {
        root->ok = true;
        root->sval = d;
        root->add = 0;
        return;
    }
    push(root);
    stroot(root->left, l, r, d);
    stroot(root->right, l, r, d);
}

void ans(node *root, int t1, int i1, int i2, int st)
{
    //cout << "ans" << ' ' << i1 << ' ' << i2 << endl;
    int cr = query(root, i2);
    //cout << cr << endl;
    if (st % 2 == 0)
        cr -= min(t1, cr);
    else
        cr += min(t1, x - cr);
    res[i1] = cr;
}

int32_t main()
{
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int k, q1, t, a;
    cin >> x >> k;
    vector<int> r(k + 2);
    vector<vector<tiii>> re(k + 1);
    r[0] = 0;
    for (int i = 0; i < k; i++)
        cin >> r[i + 1];
    r[k + 1] = INF;
    sort(r.begin(), r.end());
    cin >> q1;
    vector<tiii> q(q1);
    for (int i = 0; i < q1; i++)
    {
        cin >> t >> a;
        q[i] = mt(a, t, i);
    }
    sort(q.begin(), q.end());
    for (int i = 0; i < q1; i++)
    {
        int i1 = upper_bound(r.begin(), r.end(), get<1>(q[i])) - r.begin(); i1--;
        re[i1].push_back(mt(get<1>(q[i]), get<2>(q[i]), i));
        ar[i] = get<0>(q[i]);
    }

    node *root = build(0, q1 - 1);

    //for (int i = 0; i < q1; i++)
    //    cout << query(root, i) << ' '; cout << endl;

    for (int i = 0; i < k + 1; i++)
    {
        //cout << "iiiii" << ' ' << i << endl;
        //cout << r[i] << ' ' << r[i + 1] << ' ' << r[i + 1] - r[i] << endl;
        for (auto tu : re[i])
            ans(root, get<0>(tu) - r[i], get<1>(tu), get<2>(tu), i);
        int l1 = 0, r1 = q1;
        int step = r[i + 1] - r[i];
        //cout << step << endl;
        while (l1 < r1)
        {
            //cout << l1 << ' ' << r1 << endl;
            int cr = (l1 + r1) / 2;
            int vl = query(root, cr);
            if (i % 2 == 0)
            {
                if (vl < step)
                    l1 = cr + 1;
                else
                    r1 = cr;
            }
            else
            {
                if (vl + step <= x )
                    l1 = cr + 1;
                else
                    r1 = cr;
            }
        }
        //cout << l1 << endl;
        if (i % 2 == 0)
        {
            if (l1)
                stroot(root, 0, l1 - 1, 0);
            if (l1 < q1)
                add(root, l1, q1 - 1, 0 - step);
        }
        else
        {
            if (l1)
                add(root, 0, l1 - 1, step);
            if (l1 < q1)
                stroot(root, l1, q1 - 1, x);
        }
        //for (int i = 0; i < q1; i++)
        //    cout << query(root, i) << ' '; cout << endl;
    }

    for (int i = 0; i < q1; i++)
        cout << res[i] << endl;
    return 0;
}