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# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProCon
{

    class Program
    {
        struct TimeValue
        {
            public TimeValue(long x, long y, long z, long a)
            {
                time = x;
                diffA = y;
                MinusMax = z;
                PlusMax = a;
            }
            public long time;
            public long diffA;
            public long MinusMax;
            public long PlusMax;
        };

        static int DivideSearch(List<TimeValue> Data, long TargetTime, int IndexBegin, int IndexEnd)
        {
            if(IndexBegin + 1 == IndexEnd)
            {
                return IndexBegin;
            }
            int Tyuukan = (IndexBegin + IndexEnd) / 2;
            if( Data[Tyuukan].time >= TargetTime)
            {
                return DivideSearch( Data,TargetTime, IndexBegin, Tyuukan );
            }
            else
            {
                return DivideSearch(Data, TargetTime, Tyuukan, IndexEnd);
            }
        }

        static void Main(string[] args)
        {
            long X = long.Parse(Console.ReadLine());
            long K = long.Parse(Console.ReadLine());
            string[] input = Console.ReadLine().Split(' ');
            List<TimeValue> Data = new List<TimeValue>();
            long AValue = 0;
            long BeforeTime = 0;
            long MinusMax = 0;
            long PlusMax = 0;
            Data.Add(new TimeValue(0, 0, 0, 0));
            for (long i = 0; i < input.Count(); ++i)
            {
                long nTime = long.Parse(input[i]);
                long nDiff = nTime - BeforeTime;
                AValue += nDiff * ((i % 2 == 0) ? -1 : 1);
                MinusMax = Math.Min( MinusMax, AValue );
                PlusMax = Math.Max(PlusMax, AValue);

                Data.Add(new TimeValue( nTime, AValue, MinusMax, PlusMax));
                BeforeTime = nTime;
            }
            long Q = long.Parse(Console.ReadLine());
            for( long i = 0; i < Q; ++i)
            {
                string[] input2 = Console.ReadLine().Split(' ');
                int T = int.Parse(input2[0]);
                long A = long.Parse(input2[1]);
                int Index = DivideSearch(Data, T, 0, Data.Count());
                long MinusPenalty = Math.Min(0, A + Data[Index].MinusMax);
                long PlusPenalty = Math.Max(0, A + Data[Index].PlusMax - X);
                long Result = A + Data[Index].diffA - MinusPenalty - PlusPenalty + (T - Data[Index].time) * ((Index % 2 == 0) ? -1 : 1);
                Result = Math.Max(0, Result);
                Result = Math.Min( X, Result );
                Console.WriteLine(Result);
            }
            
        }
    }

}