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 (GCC 5.4.1) (judge verdict: Wrong Answer)

/*
cat <<EOF >mistaken-paste
*/

#pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
#define _USE_MATH_DEFINES

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#include <time.h>

#define BIG 2000000007
#define VERYBIG 200000000000007LL

#define MOD 1000000007
typedef uint64_t ull;
typedef  int64_t sll;

#define N_MAX 200000
#define M_MAX 200000

#ifdef __cplusplus
#include <queue>
#include <stack>
// #include <tuple>
#include <set>
#include <map>

// using namespace std; // HELL
using std::queue;
using std::priority_queue;
using std::stack;
// using std::tuple;
using std::set;
using std::map;
using std::vector;
using std::greater;
using std::pair;

#endif

typedef struct {
	int32_t a;
	int32_t b;
} hw;

typedef struct {
	sll a;
	sll b;
} hwll;

typedef struct {
	hwll a;
	hwll b;
} linell;


typedef struct {
	ull s;
	ull t;
	int32_t c;
} struct_a;

typedef struct {
	int32_t from;
	int32_t to;
	sll cost;
} struct_b;



const hw vector8[8] = {
	{-1, -1},
	{-1,  0},
	{-1, +1},
	{ 0, -1},
	{ 0, +1},
	{+1, -1},
	{+1,  0},
	{+1, +1}
};

ull n, m;
ull h, w;
ull k;
ull q;
ull vua, vub, vuc, vud, vue, vuf;
sll vsa, vsb, vsc, vsd, vse, vsf;
long double vra, vrb, vrc;
double vda, vdb, vdc;
size_t slen;
size_t tlen;
char ch, dh;

void swap_adj (ull *a, ull *b) {
	if (*a != *b) {
		ull tmp = *b;
		*b = *a;
		*a = tmp;
	}
	return;
}

int32_t digits (ull x) {
	int32_t i = 1;
	while (x >= 10) {
		x /= 10;
		i++;
	}
	return i;
}

ull umin (ull x, ull y) {
	return (x < y) ? x : y;
}

ull umax (ull x, ull y) {
	return (x > y) ? x : y;
}

sll smin (sll x, sll y) {
	return (x < y) ? x : y;
}

sll smax (sll x, sll y) {
	return (x > y) ? x : y;
}

ull gcd (ull x, ull y) {
	if (x < y) {
		return gcd(y, x);
	} else if (y == 0) {
		return x;
	} else {
		return gcd(y, x % y);
	}
}

ull bitpow (ull a, ull x, ull modulo) {
	ull result = 1;
	while (x) {
		if (x & 1) {
			result *= a;
			result %= modulo;
		}
		x /= 2;
		a = (a * a) % modulo;
	}
	return result;
}

ull divide (ull a, ull b, ull modulo) {
	return (a * bitpow(b, modulo - 2, modulo)) % modulo;
}

ull ullabs (ull a, ull b) {
	if (a >= b) {
		return a - b;
	} else {
		return b - a;
	}
}

sll sllabs (sll a, sll b) {
	if (a >= b) {
		return a - b;
	} else {
		return b - a;
	}
}

sll nibutanlobo (bool (*func)(sll arg), sll ok, sll ng) {
	while (sllabs(ok, ng) > 1) {
		sll med = (ok + ng) / 2;
		if (func(med)) {
			ok = med;
		} else {
			ng = med;
		}

		// printf("debug: [%lld %lld)\n", ok, ng);
	}

	if (!func(ok)) return ok * 2 - ng;
	return ok;
}

void printUquotient (ull left, ull right) {
	const int32_t digits = 20;

	printf("%llu.", left / right);
	left %= right;
	for (int32_t i = 0; i < digits; i++) {
		left *= 10;
		printf("%1d", left / right);
		left %= right;
	}
	puts("");

	return;
}

void printSquotient (sll left, sll right) {
	if (left * right < 0) putchar('-');
	printUquotient(sllabs(left, 0), sllabs(right, 0));

	return;
}

int bitcount (ull n) {
	int result = 0;
	while (n) {
		if (n & 1) result++;
		n /= 2;
	}
	return result;
}

// #ifdef __cplusplus

// typedef struct {
// 	int32_t to;
// 	sll cost;
// } edge;
// typedef pair<sll, int32_t> P;

// std::vector<edge> g[N_MAX];
// void dijk_init (ull n, struct_b arr[]) {
// 	edge x;
// 	for (int32_t i = 0; i < n; i++) {
// 		x.to = arr[i].to;
// 		x.cost = arr[i].cost;
// 		g[arr[i].from].push_back(x);
// 	}
// }

// bool dijkstra (int s, sll distance[]) {
// 	priority_queue<P, std::vector<P>, greater<P> > que; // (最短距離, 頂点番号)
// 	que.push(P(distance[s], s));

// 	bool ischanged = false;
// 	while (!que.empty()) {
// 		P p = que.top();
// 		que.pop();

// 		sll v = p.second;
// 		if (distance[v] < p.first) continue;

// 		int32_t maxsize = g[v].size();
// 		for (int32_t i = 0; i < maxsize; i++) {
// 			edge e = g[v][i];
// 			if (distance[e.to] > distance[v] + e.cost) {
// 				distance[e.to] = distance[v] + e.cost;
// 				ischanged = true;
// 				que.push(P(distance[e.to], e.to));
// 			}
// 		}
// 	}

// 	return ischanged;
// }

// #endif

sll dist[N_MAX];
struct_b path[M_MAX * 2];

// ull a[N_MAX];
// ull a[M_MAX];
sll a[N_MAX];
// ull a[N_MAX][N_MAX];
// ull a[M_MAX][M_MAX];
// sll a[N_MAX][N_MAX];
// ull b[N_MAX];
// ull b[M_MAX];
sll b[N_MAX];
// ull c[N_MAX];
sll c[M_MAX];
// char c[N_MAX];
// char s[N_MAX + 1];
// char s[N_MAX + 1][N_MAX + 1];
// char s[N_MAX + 1][M_MAX + 1];
// char t[N_MAX + 1];

// ull alphabets[26];
// ull blphabets[26];
// char alphabets[26];

// ull dp[N_MAX + 1];
// sll dp[N_MAX + 1];
// ull dp[N_MAX + 1][N_MAX + 1];
// sll dp[N_MAX + 1][N_MAX + 1];
// bool dp[N_MAX + 1];
// bool dp[N_MAX + 1][N_MAX + 1];
hwll arr[N_MAX + 1];
// hwll arr[M_MAX];
// hwll brr[M_MAX];

// sll dp[N_MAX + 1];
// ull color[N_MAX];
// set<sll> children[N_MAX];
// set<sll> leaf[N_MAX];

// bool redfill[N_MAX];

typedef struct {
	hwll min;
	hwll max;
} linedpll;

linedpll minmax[N_MAX + 1];

double distance (sll x1, sll y1, sll x2, sll y2) {
	double xdist2, ydist2, origindist, dist;

	xdist2 = (x1 - x2) * (x1 - x2);
	ydist2 = (y1 - y2) * (y1 - y2);
	return sqrt(xdist2 + ydist2);
}

int32_t pullcomp (const void *left, const void *right) {
	ull l = *(ull*)left;
	ull r = *(ull*)right;
	if (l < r) {
		return -1;
	}
	if (l > r) {
		return +1;
	}
	return 0;
}

int32_t phwllABcomp (const void *left, const void *right) {
	hwll l = *(hwll*)left;
	hwll r = *(hwll*)right;
	if (l.a < r.a) {
		return -1;
	}
	if (l.a > r.a) {
		return +1;
	}
	if (l.b < r.b) {
		return -1;
	}
	if (l.b > r.b) {
		return +1;
	}
	return 0;
}

// ull rank[N_MAX];
// ull parent[N_MAX];

// void uf_init (ull n) {
// 	for (sll i = 0; i < n; i++) {
// 		rank[i] = 0;
// 		parent[i] = i;
// 	}
// }
// ull uf_find (ull x) {
// 	if (parent[x] == x) return x;
// 	return parent[x] = uf_find(parent[x]);
// }
// bool uf_same (ull a, ull b) {
// 	return (uf_find(a) == uf_find(b));
// }
// bool uf_union (ull a, ull b) {
// 	ull ap = uf_find(a);
// 	ull bp = uf_find(b);
// 	if (ap == bp) return false;

// 	if (rank[ap] > rank[bp]) {
// 		parent[bp] = ap;
// 	} else {
// 		parent[ap] = bp;
// 		if (rank[ap] == rank[bp]) rank[bp]++;
// 	}
// 	return true;
// }

// typedef pair<ull, ull> P;
// vector<P> g[N_MAX];

// set<ull> rootpath[N_MAX];
// P directp[N_MAX];

// vector<P> doubling[N_MAX];

// P reversep (ull v, ull retn) {

// 	P result = {v, 0};
// 	sll i;

// 	while (retn) {
// 		for (i = doubling[v].size() - 1; i >= 0; i--) {
// 			if ((1 << i) & retn) {
// 				break;
// 			}
// 		}
// 		result.second = umax(result.second, doubling[v][i].second);
// 		v = result.first = doubling[v][i].first;
// 		retn -= (1 << i);
// 	}

// 	return result;
// }

ull solve () {
	sll i, j, ki;
	// ull result = 0;
	sll result = 0;
	// double result = 0;
	ull maybe = 0;
	// sll maybe = 0;
	// ull sum = 0;
	sll sum = 0;
	ull item;
	ull *dpcell;

	// uf_init(n);
	// for (i = 0; i < m; i++) {
	// 	if (!uf_same(arr[i].a, arr[i].b)) {
	// 		// printf("%llu/%llu...\n", arr[i].a, arr[i].b);
	// 		// fflush(stdout);
	// 		uf_union(arr[i].a, arr[i].b);
	// 		// path[pathnum * 2].from = path[pathnum * 2 + 1].to = arr[i].a;
	// 		// path[pathnum * 2].to = path[pathnum * 2 + 1].from = arr[i].b;
	// 		// path[pathnum * 2].cost = path[pathnum * 2 + 1].cost = i;

	// 		// printf("%llu/%llu <- P(%llu/%llu, %llu)\n", arr[i].a, arr[i].b, arr[i].b, arr[i].a, i + 1);
	// 		// fflush(stdout);

	// 		g[arr[i].a].push_back(P(arr[i].b, i + 1));
	// 		g[arr[i].b].push_back(P(arr[i].a, i + 1));
	// 	}
	// }

	// for (i = 0; i < n; i++) {
	// 	if (uf_find(i) == i) {
	// 		queue<ull> q;
	// 		q.push(i);

	// 		directp[i] = P(i, 0);
	// 		rootpath[i].insert(i);

	// 		while (!q.empty()) {
	// 			ull v = q.front();
	// 			q.pop();

	// 			for (P p : g[v]) {
	// 				ull c = p.first;
	// 				if (rootpath[c].find(c) != rootpath[c].end()) continue;

	// 				directp[c] = P(v, p.second);
	// 				rootpath[c] = rootpath[v];
	// 				rootpath[c].insert(c);

	// 				q.push(c);
	// 			}
	// 		}
	// 	}
	// }

	// // doubling
	// for (i = 0; (1 << i) <= n; i++) {
	// 	for (j = 0; j < n; j++) {
	// 		if (rootpath[j].size() - 1 < (1 << i)) continue;

	// 		if (i == 0) {
	// 			doubling[j].push_back(P(directp[j].first, directp[j].second));
	// 		} else {
	// 			P medp = doubling[j][i - 1];
	// 			doubling[j].push_back(P(
	// 				doubling[medp.first][i - 1].first,
	// 				umax(medp.second, doubling[medp.first][i - 1].second)
	// 				)
	// 			);
	// 		}
	// 	}
	// }

	// for (i = 0; i < q; i++) {
	// 	if (!uf_same(a[i], b[i])) {
	// 		puts("-1");
	// 		continue;
	// 	}


	// 	sll ok, ng;

	// 	ok = rootpath[b[i]].size(), ng = -1;
	// 	while (ok - ng > 1) {
	// 		sll med = (ok + ng) / 2;

	// 		sll revp = reversep(b[i], med).first;
	// 		if (rootpath[a[i]].find(revp) != rootpath[a[i]].end()) {
	// 			ok = med;
	// 		} else {
	// 			ng = med;
	// 		}
	// 	}

	// 	result = reversep(b[i], ok).second;

	// 	ok = rootpath[a[i]].size(), ng - -1;
	// 	while (ok - ng > 1) {
	// 		sll med = (ok + ng) / 2;

	// 		sll revp = reversep(a[i], med).first;
	// 		if (rootpath[b[i]].find(revp) != rootpath[b[i]].end()) {
	// 			ok = med;
	// 		} else {
	// 			ng = med;
	// 		}
	// 	}

	// 	result = umax(result, reversep(a[i], ok).second);

	// 	// ull nearestp = b[i];

	// 	// while (rootpath[a[i]].find(nearestp) == rootpath[a[i]].end()) {
	// 	// 	nearestp = directp[nearestp].first;
	// 	// }

	// 	// result = 0;
	// 	// ull currv;

	// 	// currv = a[i];
	// 	// while (currv != nearestp) {
	// 	// 	result = umax(result, directp[currv].second);
	// 	// 	currv = directp[currv].first;
	// 	// }
	// 	// currv = b[i];
	// 	// while (currv != nearestp) {
	// 	// 	result = umax(result, directp[currv].second);
	// 	// 	currv = directp[currv].first;
	// 	// }

	// 	printf("%llu\n", result);
	// }

	linedpll initial = {{0, 0}, {k, k}};
	minmax[0] = initial;

	for (i = 0; i < n; i++) {
		bool isdecre = (i % 2 == 0);
		ull time = a[i] - (i ? a[i - 1] : 0);

		if (isdecre) {
			if (minmax[i].min.b >= time) {
				minmax[i + 1] = minmax[i];
				minmax[i + 1].min.b -= time;
				minmax[i + 1].max.b -= time;
			} else if (minmax[i].max.b < time) {
				linedpll x = {{0, 0}, {0, 0}};
				minmax[i + 1] = x;
			} else {
				sll pilled = time - minmax[i].min.b;

				minmax[i + 1] = minmax[i];
				minmax[i + 1].max.b -= time;

				minmax[i + 1].min.a += pilled;
				minmax[i + 1].min.b = 0;
			}
		} else {
			if (minmax[i].max.b <= k - time) {
				minmax[i + 1] = minmax[i];
				minmax[i + 1].min.b += time;
				minmax[i + 1].max.b += time;
			} else if (minmax[i].min.b > k - time) {
				linedpll x = {{k, k}, {k, k}};
				minmax[i + 1] = x;
			} else {
				sll pilled = minmax[i].max.b - (k - time);

				minmax[i + 1] = minmax[i];
				minmax[i + 1].min.b += time;

				minmax[i + 1].max.a -= pilled;
				minmax[i + 1].max.b = k;
			}
		}

		// printf("%lld: ~%lld:%llu, %lld~: %llu\n", i + 1, minmax[i + 1].min.a, minmax[i + 1].min.b, minmax[i + 1].max.a, minmax[i + 1].max.b);
	}

	sll lastrev = 0;
	for (i = 0; i < q; i++) {
		while (lastrev < n && a[lastrev] <= arr[i].a) lastrev++;

		bool isdecre = (lastrev % 2 == 0);

		ull moret = arr[i].a - (lastrev ? a[lastrev - 1] : 0);
		if (isdecre) {
			sll pill;
			if (arr[i].b < minmax[lastrev].min.a) {
				pill = 0;
			} else {
				pill = smin(arr[i].b, minmax[lastrev].max.a) - minmax[lastrev].min.a;
			}
			// printf("[%lld, %lld]\n", lastrev, pill);

			result = smax(minmax[lastrev].min.b + pill - moret, 0);
		} else {
			sll pill;
			if (arr[i].b > minmax[lastrev].max.a) {
				pill = 0;
			} else {
				pill = minmax[lastrev].max.a - smax(arr[i].b, minmax[lastrev].min.a);
			}
			// printf("[%lld, %lld]\n", lastrev, pill);

			result = smin(minmax[lastrev].max.b - pill + moret, k);
		}

		printf("%lld\n", result);
	}

	// // printf("%llu\n", result);
	// // printf("%.12lf\n", (double)result);
	// // puts(s);

	return 0;

	success:
	puts("YES");
	// puts("Yes");
	// printf("%llu\n", result);
	// puts("0");
	// puts("Possible");
	return 0;

	fail:
	puts("NO");
	// puts("No");
	// puts("0");
	// puts("-1");
	// puts("-1 -1 -1");
	// puts("Impossible");
	return 1;
}

int32_t main (void) {
	int32_t i, j;
	int32_t x, y;

	// scanf("%lf%lf", &vda, &vdb);
	// scanf("%lld%lld%lld%lld", &vsa, &vsb, &vsc, &vsd);
	// scanf("%llu%llu", &vua, &vub, &vuc, &vud);
	// scanf("%llu%llu", &h, &w);
	// scanf("%*llu%*llu");
	// scanf("%llu%llu", &n, &m);
	scanf("%llu%llu", &k, &n);
	// scanf("%llu%llu", &vua, &vub, &vuc, &vud, &vue, &vuf);
	// scanf("%lld%lld", &vsa, &vsb, &vsc);
	// scanf("%s", s);
	// scanf("%s", t);
	// scanf("%llu", &m);
	// scanf("%llu", &q);
	for (i = 0; i < n; i++) {
		scanf("%llu", &a[i]);
		// a[i]--;
	}
	// for (i = 0; i < m; i++) {
	// 	scanf("%llu", &b[i]);
	// }
	// for (i = 0; i < h; i++) {
	// 	scanf("%llu", &a[i]);
	// }
	// for (i = 0; i < h; i++) {
	// 	for (j = 0; j < w; j++) {
	// 		scanf("%llu", &a[i][j]);
	// 	}
	// }

	// for (i = 0; i < w; i++) {
	// 	scanf("%llu", &b[i]);
	// }	
	// for (i = 0; i < m; i++) {
	// 	scanf("%llu", &b[i]);
	// }
	// for (i = 0; i < h; i++) {
	// 	scanf("%s", s[i]);
	// }
	// scanf("%s", t);
	// for (i = 0; i < m; i++) {
	// 	// scanf("%lld", &a[i]);
	// 	// scanf("%lld", &b[i]);
	// 	scanf("%llu", &arr[i].a);
	// 	scanf("%llu", &arr[i].b);
	// 	// scanf("%llu", &c[i]);
	// 	arr[i].a--;
	// 	arr[i].b--;
	// 	// a[i]--;
	// 	// b[i]--;
	// }
	// // for (i = 0; i < k; i++) {
	// 	scanf("%llu", &c[i]);
	// 	c[i]--;
	// }
	// for (i = 0; i < m; i++) {
	// 	scanf("%llu%llu", &arr[i].a, &arr[i].b);
	// 	arr[i].a--;
	// 	arr[i].b--;
	// }
	// for (i = 0; i < k; i++) {
	// 	scanf("%llu%llu", &brr[i].a, &brr[i].b);
	// 	brr[i].a--;
	// 	brr[i].b--;
	// }
	// for (i = 0; i < m; i++) {
	// 	for (j = 0; j < m; j++) {
	// 		scanf("%llu", &a[i][j]);
	// 	}
	// }
	// for (i = 0; i < n; i++) {
	// 	scanf("%llu%llu%llu", &a[i], &b[i], &c[i]);
	// }

	scanf("%llu", &q);
	// scanf("%llu", &k);
	// k--;
	for (i = 0; i < q; i++) {
		scanf("%llu%llu", &arr[i].a, &arr[i].b);
		// scanf("%llu%llu", &a[i], &b[i]);
		// a[i]--;
		// b[i]--;
		// arr[i].a--;
		// arr[i].b--;
		// solve();
	}

	// for (i = 0; i < m; i++) {
	// 	scanf("%llu%llu", &arr[i].a, &arr[i].b);
	// 	arr[i].a--;
	// 	arr[i].b--;
	// }
	// for (i = 0; i < n; i++) {
	// 	for (j = 0; j < m; j++) {
	// 		scanf("%llu", &a[i][j]);
	// 		a[i][j]--;
	// 	}
	// }

	solve();

	// for (i = 0; i < m; i++) {
	// 	scanf("%llu%llu%llu", &vua, &vub, &vuc);
	// 	// scanf("%s%s", s, t);
	// 	// scanf("%f%f%f", &vda, &vdb, &vdc);
	// 	// scanf("%s", s);
	// 	solve();
	// }

	// while (scanf("%llu%llu", &n, &k), n + k) {
	// 	for (i = 0; i < n; i++) {
	// 		scanf("%llu", &a[i]);
	// 	}
	// 	solve();
	// }

	return 0;
}