Given a positive integer k, two arrays are called k-similar if:

  * they are strictly increasing; 
  * they have the same length; 
  * all their elements are positive integers between 1 and k (inclusive); 
  * they differ in exactly one position. 



You are given an integer k, a strictly increasing array a and q queries. For each query, you are given two integers l_i ≤ r_i. Your task is to find how many arrays b exist, such that b is k-similar to array [a_{l_i},a_{l_i+1}…,a_{r_i}]. 

Input

The first line contains three integers n, q and k (1≤ n, q ≤ 10^5, n≤ k ≤ 10^9) — the length of array a, the number of queries and number k.

The second line contains n integers a_1, a_2, …,a_n (1 ≤ a_i ≤ k). This array is strictly increasing — a_1 < a_2 < … < a_n.

Each of the following q lines contains two integers l_i, r_i (1 ≤ l_i ≤ r_i ≤ n).

Output

Print q lines. The i-th of them should contain the answer to the i-th query.

Examples

Input


4 2 5
1 2 4 5
2 3
3 4


Output


4
3


Input


6 5 10
2 4 6 7 8 9
1 4
1 2
3 5
1 6
5 5


Output


8
9
7
6
9

Note

In the first example:

In the first query there are 4 arrays that are 5-similar to [2,4]: [1,4],[3,4],[2,3],[2,5].

In the second query there are 3 arrays that are 5-similar to [4,5]: [1,5],[2,5],[3,5].
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
from collections import deque


def main():
    n, q, k = inLst()
    A = inLst()
    changes = [0] * n
    if n == 1:
        changes[0] = k - 1
    else:
        changes[0] = A[1] - 2
        changes[-1] = k - A[-2] - 1
        for i in range(1, n-1):
            l = A[i-1]
            r = A[i + 1]
            changes[i] = r - l - 2
    prefix = changes[:]
    for i in range(1, n):
        prefix[i] += prefix[i-1]

    for _ in range(q):
        l, r = inLst()
        if l == r:
            outInt(k-1)
            continue
        l -= 1
        r -= 1
        res = 0
        res += A[l+1] - 1
        res += k - A[r-1] - 2
        res += prefix[r-1] - prefix[l]
        outInt(res) 
    

# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

############ ---- Input Functions ---- ############
# Integer inputs
inInt = lambda: int(input())
# List inputs
inLst = lambda: list(map(int,input().split()))
# String input (transforms into list of chars)
inStr = lambda: list(input())
# Space separated integer variable inputs
inVar = lambda: map(int,input().split())

########### ---- Output Functions ---- ############
# Print integer
outInt = lambda n: sys.stdout.write(str(n) + "\n")
# Print integer list 
outLst = lambda lst: sys.stdout.write(" ".join(map(str,lst)) + "\n")
# Print string
outStr = lambda s: sys.stdout.write("".join(s) + "\n")

# endregion

if __name__ == "__main__":
    main()
