Problem: Nauuo is a girl who loves coding.

One day she was solving a problem which requires to calculate a sum of some numbers modulo p.

She wrote the following code and got the verdict "Wrong answer".

<image>

She soon discovered the bug — the ModAdd function only worked for numbers in the range [0,p), but the numbers in the problem may be out of the range. She was curious about the wrong function, so she wanted to know the result of it.

However, the original code worked too slow, so she asked you to help her.

You are given an array a_1,a_2,…,a_n and a number p. Nauuo will make m queries, in each query, you are given l and r, and you have to calculate the results of Sum(a,l,r,p). You can see the definition of the Sum function in the pseudocode above.

Note that the integers won't overflow in the code above.

Input

The first line contains three integers n, m, p (1 ≤ n ≤ 10^6, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ p ≤ 10^9) — the length of the given array, the number of queries and the modulus. Note that the modulus is used only in the ModAdd function.

The second line contains n integers a_1,a_2,…,a_n (-10^9≤ a_i≤10^9) — the given array.

In the following m lines, each line contains two integers l, r (1≤ l≤ r≤ n) — you have to calculate the result of Sum(a,l,r,p).

Output

The output contains m integers to answer the queries in the given order.

Example

Input


4 5 6
7 2 -3 17
2 3
1 3
1 2
2 4
4 4


Output


-1
0
3
10
11

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
const double eps = 1e-10;
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
  return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
  return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
  return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
  return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
  (a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
  (b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const _Tp &a,
                                                    const _Tp &b) {
  return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
  register char ch(getchar());
  bool f(false);
  while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
  x = ch & 15, ch = getchar();
  while (ch >= 48 && ch <= 57)
    x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
  if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
  read(t);
  read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
  register char ch(getchar());
  while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
  register char *tar = s;
  *tar = ch, ch = getchar();
  while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
    *(++tar) = ch, ch = getchar();
  return tar - s + 1;
}
const int N = 1000005;
int p;
int a[N];
long long ans;
struct seg_tr {
  struct Node {
    int ls, rs;
    long long sum;
    std::vector<long long> c;
  } f[N << 1];
  int node_cnt;
  __inline__ __attribute__((always_inline)) void PushUp(int x) {
    f[x].sum = f[f[x].ls].sum + f[f[x].rs].sum;
    std::vector<long long> c1 = f[f[x].ls].c, c2 = f[f[x].rs].c;
    long long s1 = f[f[x].ls].sum;
    int pos = 0;
    for (int i = 0; i + 1 < ((int)c1.size()); ++i) {
      if (pos) --pos;
      long long l = c1[i] - 1ll * i * p + s1;
      long long r = c1[i + 1] - 1 - 1ll * i * p + s1;
      while (pos + 1 < ((int)c2.size())) {
        if (c2[pos] > r) {
          if (pos) --pos;
          break;
        }
        if (l <= c2[pos])
          chmin(f[x].c[i + pos], c2[pos] + 1ll * i * p - s1);
        else if (c2[pos + 1] > l)
          chmin(f[x].c[i + pos], c1[i]);
        ++pos;
      }
    }
  }
  int build(int l, int r) {
    int cur = ++node_cnt;
    if (l == r) {
      f[cur].c.resize(3);
      f[cur].sum = a[l];
      f[cur].c[0] = -1e18;
      f[cur].c[1] = p - a[l];
      f[cur].c[2] = 1e18;
      return cur;
    }
    int mid = (l + r) >> 1;
    f[cur].ls = build(l, mid);
    f[cur].rs = build(mid + 1, r);
    f[cur].c.resize(r - l + 3);
    for (auto &&it : f[cur].c) it = 1e18;
    PushUp(cur);
    return cur;
  }
  void Query(int L, int R, int l, int r, int cur) {
    if (L <= l && r <= R) {
      int l = 0, r = ((int)f[cur].c.size()) - 1;
      while (l < r) {
        int mid = (l + r + 1) >> 1;
        if (ans >= f[cur].c[mid])
          l = mid;
        else
          r = mid - 1;
      }
      ans -= 1ll * l * p;
      ans += f[cur].sum;
      return;
    }
    int mid = (l + r) >> 1;
    if (L <= mid) Query(L, R, l, mid, f[cur].ls);
    if (R > mid) Query(L, R, mid + 1, r, f[cur].rs);
  }
} tr;
int main() {
  int n, m;
  read(n, m, p);
  for (int i = 1; i <= n; ++i) read(a[i]);
  tr.build(1, n);
  int x, y;
  while (m--) {
    read(x, y);
    ans = 0;
    tr.Query(x, y, 1, n, 1);
    printf("%lld\n", ans);
  }
  return 0;
}