Problem: So we got bored and decided to take our own guess at how would "Inception" production go if the budget for the film had been terribly low.

The first scene we remembered was the one that features the whole city bending onto itself:

<image>

It feels like it will require high CGI expenses, doesn't it? Luckily, we came up with a similar-looking scene which was a tiny bit cheaper to make.

Firstly, forget about 3D, that's hard and expensive! The city is now represented as a number line (infinite to make it easier, of course).

Secondly, the city doesn't have to look natural at all. There are n buildings on the line. Each building is a square 1 × 1. Buildings are numbered from 1 to n in ascending order of their positions. Lower corners of building i are at integer points a_i and a_i + 1 of the number line. Also the distance between any two neighbouring buildings i and i + 1 doesn't exceed d (really, this condition is here just to make the city look not that sparse). Distance between some neighbouring buildings i and i + 1 is calculated from the lower right corner of building i to the lower left corner of building i + 1.

Finally, curvature of the bend is also really hard to simulate! Let the bend at some integer coordinate x be performed with the following algorithm. Take the ray from x to +∞ and all the buildings which are on this ray and start turning the ray and the buildings counter-clockwise around point x. At some angle some building will touch either another building or a part of the line. You have to stop bending there (implementing buildings crushing is also not worth its money). 

Let's call the angle between two rays in the final state the terminal angle α_x.

The only thing left is to decide what integer point x is the best to start bending around. Fortunately, we've already chosen m candidates to perform the bending.

So, can you please help us to calculate terminal angle α_x for each bend x from our list of candidates?

Input

The first line contains two integer numbers n and d (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ d ≤ 7000) — the number of buildings and the maximum distance between any pair of neighbouring buildings, respectively.

The second line contains n integers a_1, a_2, ..., a_n (a_1 = 0, 0 < a_{i + 1} - a_i ≤ d + 1) — coordinates of left corners of corresponding buildings in ascending order.

The third line contains single integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of candidates.

The fourth line contains m integers x_1, x_2, ..., x_m (0 ≤ x_i ≤ a_n + 1, x_i < x_{i + 1}) — the coordinates of bends you need to calculate terminal angles for in ascending order.

Output

Print m numbers. For each bend x_i print terminal angle α_{x_i} (in radians).

Your answer is considered correct if its absolute error does not exceed 10^{-9}.

Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if |a - b| ≤ 10^{-9}.

Examples

Input


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


Output


1.570796326794897
1.570796326794897
0.785398163397448
0.927295218001612
0.785398163397448
1.570796326794897
1.570796326794897
1.570796326794897
1.570796326794897


Input


2 7
0 4
3
1 3 4


Output


1.570796326794897
0.927295218001612
1.570796326794897


Input


5 0
0 1 2 3 4
6
0 1 2 3 4 5


Output


1.570796326794897
3.141592653589793
3.141592653589793
3.141592653589793
3.141592653589793
1.570796326794897

Note

Here you can see the picture of the city for the first example and the bend at position 2 for it. The angle you need to measure is marked blue. You can see that it's equal to \frac π 4.

You can see that no pair of neighbouring buildings have distance more than 4 between them. d = 4 would also suffice for that test.

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using std::lower_bound;
using std::max;
using std::min;
using std::swap;
const int MAXN = 200011;
const int MAXM = 200011;
int Low[65536];
const double PI = acos(-1.0);
int N, D, M;
int A[MAXN];
int Q[MAXM];
void Show(double a) { printf("%.12lf\n", a); }
double Tag(int k) { return atan2(1.0, (double)(k)); }
void Show_(int k) { Show(Tag(k)); }
void Show__(int k) { Show(2.0 * Tag(k)); }
bool Fetch(int p) {
  int r = lower_bound(A + 1, A + N + 1, p) - A;
  bool ret = false;
  if (r > 1) ret |= (A[r - 1] + 1) == p;
  if (r <= N) ret |= (A[r] == p);
  return ret;
}
int lowbit_(int k) {
  return ((k & 65535) != 0) ? Low[k & 65535] : (Low[k >> 16] + 16);
}
struct Bitset {
  int v[300];
  int lowbit() {
    int ret = 666666;
    for (int i = 0; i < 300; ++i) {
      if (v[i]) {
        ret = min(ret, lowbit_(v[i]) + i * 30);
        break;
      }
    }
    return ret;
  }
  void set(int p) { v[p / 30] |= (1 << (p % 30)); }
};
Bitset operator>>(Bitset B, int k) {
  int t;
  t = k / 30;
  for (int i = 0; i < 300; ++i) {
    B.v[i] = (i + t < 300) ? B.v[i + t] : 0;
  }
  t = k % 30;
  for (int i = 0; i < 300; ++i) {
    B.v[i] = (B.v[i] >> t) |
             ((((1 << t) - 1) & ((i == 299) ? 0 : B.v[i + 1])) << (30 - t));
  }
  return B;
}
Bitset operator<<(Bitset B, int k) {
  int t;
  t = k / 30;
  for (int i = 299; i >= 0; --i) {
    B.v[i] = (i - t) >= 0 ? B.v[i - t] : 0;
  }
  t = k % 30;
  for (int i = 299; i >= 0; --i) {
    B.v[i] = ((((1 << (30 - t)) - 1) & B.v[i]) << t) |
             (((i == 0) ? 0 : B.v[i - 1]) >> (30 - t));
  }
  return B;
}
Bitset operator&(Bitset &A, Bitset &B) {
  Bitset ret;
  for (int i = 0; i < 300; ++i) ret.v[i] = A.v[i] & B.v[i];
  return ret;
}
inline bool Norm(const int &p) { return p >= 0 && p <= 8500; }
struct Data {
  Bitset Lb, Rb;
  int l, p, r;
  double val() {
    int k = (Lb & Rb).lowbit();
    return (k >= 666666) ? 0.0 : 2.0 * Tag(k);
  }
  void move(int t) {
    Lb = Lb << (t - p);
    Rb = Rb >> (t - p);
    p = t;
    if (l && Norm(p - A[l])) Lb.set(p - A[l]);
    if (l && Norm(p - (A[l] + 1))) Lb.set(p - (A[l] + 1));
    while (l < N && A[l + 1] <= p) {
      ++l;
      if (Norm(p - A[l])) Lb.set(p - A[l]);
      if (Norm(p - (A[l] + 1))) Lb.set(p - (A[l] + 1));
    }
    if (r && Norm(A[r] - p)) Rb.set(A[r] - p);
    if (r && Norm((A[r] + 1) - p)) Rb.set((A[r] + 1) - p);
    while (r < N && A[r + 1] <= p + 8500) {
      ++r;
      if (Norm(A[r] - p)) Rb.set(A[r] - p);
      if (Norm((A[r] + 1) - p)) Rb.set((A[r] + 1) - p);
    }
  }
} Da;
int main() {
  for (int i = 1; i < 65536; ++i) Low[i] = (i & 1) ? 0 : (Low[i >> 1] + 1);
  scanf("%d%d", &N, &D);
  for (int i = 1; i <= N; ++i) scanf("%d", &A[i]);
  scanf("%d", &M);
  for (int i = 1; i <= M; ++i) scanf("%d", &Q[i]);
  for (int i = 1, p, l, r; i <= M; ++i) {
    p = lower_bound(A + 1, A + N + 1, Q[i]) - A;
    if (p == 1) {
      Show_(A[p] - Q[i]);
    } else if (p == N + 1) {
      Show_(Q[i] - A[p - 1] - 1);
    } else {
      r = A[p] - Q[i];
      l = Q[i] - A[p - 1] - 1;
      if (l == r) {
        Show__(l | r);
      } else if (min(l, r) == 0)
        Show(0.5 * PI);
      else {
        double Max = 0.0;
        Max = max(Max, Tag(min(l, r)));
        Da.move(Q[i]);
        Max = max(Da.val(), Max);
        Show(Max);
      }
    }
  }
  return 0;
}