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 Rust (1.15.1) (judge verdict: Accepted)

use std::io;
use std::io::{Read, BufReader};
use std::cmp;

macro_rules! read {
    ( $( $t:ty ),* ) => {
        {
            let mut buf = String::new();
            io::stdin().read_line(&mut buf);
            let mut sp = buf.trim().split(" ");
            ($(
                {
                    sp.next().unwrap().parse::<$t>().unwrap()
                },
            )*)
        }
    }
}
macro_rules! read_vec {
    ($t:ty) => {
        {
            let mut buf = String::new();
            io::stdin().read_line(&mut buf);
            let mut sp = buf.trim().split(" ");
            let mut ret = vec![];
            for s in sp {
                ret.push(s.parse::<$t>().unwrap());
            }
            ret
        }
    }
}

fn trunc((low, hi, app): (i64, i64, i64), x: i64) -> (i64, i64, i64) {
    let (mut low, mut hi, mut app) = (low, hi, app);

    hi = cmp::min(hi, x);
    low = cmp::max(low, 0);
    low = cmp::min(low, x);
    hi = cmp::max(hi, 0);

    (low, hi, app)
}
fn eval((low, hi, app): (i64, i64, i64), x: i64) -> i64 {
    cmp::min(hi, cmp::max(low, app + x))
}
fn main() {
    let (x,) = read!(i64);
    let (k,) = read!(usize);
    let rs = read_vec!(i64);
    let (q,) = read!(usize);
    
    let mut dir = 0; // 0: decl, 1: incl
    let (mut low, mut hi, mut app) = (0i64, x, 0i64);

    let mut pos = 0;
    let mut last_app = 0i64;

    for _ in 0..q {
        let (t, a) = read!(i64, i64);

        while pos < k && rs[pos] <= t {
            let df = if dir == 0 { -(rs[pos] - last_app) } else { rs[pos] - last_app };
            low += df;
            hi += df;
            app += df;
            let a = trunc((low, hi, app), x);
            low = a.0;
            hi = a.1;
            app = a.2;
            dir = 1 - dir;
            last_app = rs[pos];
            pos += 1;
        }

        let df = if dir == 0 { -(t - last_app) } else { t - last_app };
        let (low2, hi2, app2) = trunc((low + df, hi + df, app + df), x);

        let ans = eval((low2, hi2, app2), a);
        println!("{}", ans);
    }
}