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: Runtime Error)

#include<bits/stdc++.h>
long long X,n,k,Q;
bool sx=1;//1代表a在上面，要减； 

struct shalou{
	int t;
	int va;
};//定义用来表示每次变化的结构体 

struct xunwen{
	int aq;
	int tq;
	int ans;
};//定义每次询问的结构体 

xunwen *x;//询问结构体变量 

shalou *s,*zero,*eks;//沙漏结构体变量 

int main()
{
	scanf("%d%d",&X,&n);
	
	s=new shalou[n+1];
	zero=new shalou[n+1];
	eks=new shalou[n+1];//为沙漏变化结构体申请空间 
	
	for(int i=1;i<=n;i++)
		{
		scanf("%d",&s[i].t);
		zero[i].t=s[i].t;
		eks[i].t=s[i].t;
		}//读入其时间
		zero[n+1].t=s[n+1].t=eks[n+1].t=s[n].t+100000;
	
	scanf("%d",&Q);
	
	x=new xunwen[Q+1];	 //为询问变化结构体申请空间 
	
	for(int i=1;i<=Q;i++)
	scanf("%d%d",&x[i].tq,&x[i].aq);//读入其询问内容 
	
	s[0].t=zero[0].t=eks[0].t=0;//时间以0为初始 
	zero[0].va=0;//用0走 
	eks[0].va=X;//用X走 
	
	for(k=1;k<=n+1;k++)//走0 
		{
			if(sx==1)
			{
				zero[k].va=zero[k-1].va-(zero[k].t-zero[k-1].t);
				if(zero[k].va<0)
				zero[k].va=0;
				sx=0;
			}
			else
			{
				zero[k].va=zero[k-1].va+(zero[k].t-zero[k-1].t);
				if(zero[k].va>X)
				zero[k].va=X;
				sx=1;
			}
		}
		sx=1; 
		 
		 for(k=1;k<=n+1;k++)//走X 
		{
			if(sx==1)
			{
				eks[k].va=eks[k-1].va-(eks[k].t-eks[k-1].t);
				if(eks[k].va<0)
				eks[k].va=0;
				sx=0;
			}
			else
			{
				eks[k].va=eks[k-1].va+(eks[k].t-eks[k-1].t);
				if(eks[k].va>X)
				eks[k].va=X;
				sx=1;
			}
		}
		sx=1;
		int l=1;
		while(zero[l].va!=eks[l].va)
		l++;
	for(int i=1;i<=Q;i++)//走询问 
	{
		
		s[0].va=x[i].aq;//不同的初始化值 
		int j=1;
		while(x[i].tq>s[j].t)
		j++;
		    if(s[j-1].t>=zero[l].t)
		{ 
		if(j%2!=0)
	   {
	   	x[i].ans=zero[j-1].va-(x[i].tq-zero[j-1].t);
	   	if(x[i].ans<0)
	   	x[i].ans=0;
	   }
	   else
	   {
	   	x[i].ans=zero[j-1].va+(x[i].tq-zero[j-1].t);
	   	if(x[i].ans>X)
	   	x[i].ans=X;
	   	sx=1;
	   }
	   }
		 
		 else
		  {
		 for(k=1;k<j;k++)
		    {
		    
			if(sx==1)
			{
				s[k].va=s[k-1].va-(s[k].t-s[k-1].t);
				sx=0;
			}
			
			else
			{
				s[k].va=s[k-1].va+(s[k].t-s[k-1].t);
				sx=1;
			}
			
			}
			
			if(s[k-1].va<=zero[k-1].va)
			s[k-1].va=zero[k-1].va;
			
			else if(s[k-1].va>=eks[k-1].va)
			s[k-1].va=eks[k-1].va;
			
			else
			{
			sx=1;	
			for(k=1;k<j;k++)
		{
			if(sx==1)
			{
				s[k].va=s[k-1].va-(s[k].t-s[k-1].t);
				if(s[k].va<0)
				s[k].va=0;
				sx=0;
			}
			else
			{
				s[k].va=s[k-1].va+(s[k].t-s[k-1].t);
				if(s[k].va>X)
				s[k].va=X;
				sx=1;
			}
        }
           
		   } 
		   
	   if(sx==1)
	   {
	   	x[i].ans=s[k-1].va-(x[i].tq-s[k-1].t);
	   	if(x[i].ans<0)
	   	x[i].ans=0;
	   }
	   else
	   {
	   	x[i].ans=s[k-1].va+(x[i].tq-s[k-1].t);
	   	if(x[i].ans>X)
	   	x[i].ans=X;
	   	sx=1;
	   }}
	   printf("%d\n",x[i].ans);
	}
	return 0; }