Problem: The cool breeze blows gently, the flowing water ripples steadily.

"Flowing and passing like this, the water isn't gone ultimately; Waxing and waning like that, the moon doesn't shrink or grow eventually."

"Everything is transient in a way and perennial in another."

Kanno doesn't seem to make much sense out of Mino's isolated words, but maybe it's time that they enjoy the gentle breeze and the night sky — the inexhaustible gifts from nature.

Gazing into the sky of stars, Kanno indulges in a night's tranquil dreams. 

There is a set S of n points on a coordinate plane.

Kanno starts from a point P that can be chosen on the plane. P is not added to S if it doesn't belong to S. Then the following sequence of operations (altogether called a move) is repeated several times, in the given order:

  1. Choose a line l such that it passes through at least two elements in S and passes through Kanno's current position. If there are multiple such lines, one is chosen equiprobably. 
  2. Move to one of the points that belong to S and lie on l. The destination is chosen equiprobably among all possible ones, including Kanno's current position (if it does belong to S). 



There are q queries each consisting of two integers (t_i, m_i). For each query, you're to help Kanno maximize the probability of the stopping position being the t_i-th element in S after m_i moves with a proper selection of P, and output this maximum probability. Note that according to rule 1, P should belong to at least one line that passes through at least two points from S.

Input

The first line contains a positive integer n (2 ≤ n ≤ 200) — the number of points in S.

The i-th of the following n lines contains two space-separated integers x_i and y_i (-10^4 ≤ x_i, y_i ≤ 10^4) — the coordinates of the i-th point in S. The input guarantees that for all 1 ≤ i < j ≤ n, (x_i, y_i) ≠ (x_j, y_j) holds.

The next line contains a positive integer q (1 ≤ q ≤ 200) — the number of queries.

Each of the following q lines contains two space-separated integers t and m (1 ≤ t_i ≤ n, 1 ≤ m_i ≤ 10^4) — the index of the target point and the number of moves, respectively.

Output

Output q lines each containing a decimal number — the i-th among them denotes the maximum probability of staying on the t_i-th point after m_i steps, with a proper choice of starting position P.

Your answer will be considered correct if each number in your output differs from the corresponding one in jury's answer by at most 10^{-6}.

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

Example

Input

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


Output

0.50000000000000000000
0.50000000000000000000
0.33333333333333331483
0.50000000000000000000
0.50000000000000000000
0.18518518518518517491
0.15226337448559670862
0.14494741655235482414
0.14332164812274550414
0.14296036624949901017

Note

The points in S and possible candidates for line l are depicted in the following figure.

<image>

For the first query, when P = (-1, -3), l is uniquely determined to be 3x = y, and thus Kanno will move to (0, 0) with a probability of \frac 1 2.

For the third query, when P = (2, 2), l is chosen equiprobably between x + y = 4 and x = y. Kanno will then move to the other four points with a probability of \frac 1 2 ⋅ \frac 1 3 = \frac 1 6 each, or stay at (2, 2) with a probability of \frac 1 3.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
void maximize(double &a, double b) { a = max(a, b); }
struct point {
  long long int x, y;
  point() {}
  point(long long int x, long long int y) : x(x), y(y) {}
};
long long int prodesc(point p1, point p2) { return p1.x * p2.x + p1.y * p2.y; }
long long int prodvec(point p1, point p2) { return p1.x * p2.y - p1.y * p2.x; }
point operator-(point p1, point p2) { return point(p1.x - p2.x, p1.y - p2.y); }
struct line {
  point p, v;
  line() {}
  line(point p, point v) : p(p), v(v) {}
};
bool belongs(point p, line l) { return prodvec(l.p - p, l.v) == 0; }
int n;
vector<vector<double> > operator*(vector<vector<double> > m1,
                                  vector<vector<double> > m2) {
  vector<vector<double> > m(n, vector<double>(n, 0));
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++) m[i][j] += m1[i][k] * m2[k][j];
  return m;
}
vector<double> operator*(vector<double> v, vector<vector<double> > m) {
  vector<double> r(n, 0);
  for (int j = 0; j < n; j++)
    for (int i = 0; i < n; i++) r[j] += v[i] * m[i][j];
  return r;
}
const int limit = 205;
point p[limit];
int nl;
vector<int> p2l[limit];
vector<int> l2p[limit * limit];
const int tope = 15;
vector<vector<double> > vm[tope];
int main() {
  cout.setf(ios::fixed);
  cout.precision(10);
  ios::sync_with_stdio(false);
  cin >> n;
  for (int i = 0; i < n; i++) cin >> p[i].x >> p[i].y;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      line l(p[i], p[j] - p[i]);
      bool error = false;
      for (int k = 0; k < j and not error; k++)
        error = k != i and belongs(p[k], l);
      if (not error) {
        for (int k = 0; k < n; k++) {
          if (belongs(p[k], l)) {
            p2l[k].push_back(nl);
            l2p[nl].push_back(k);
          }
        }
        nl++;
      }
    }
  }
  vector<vector<double> > m(n, vector<double>(n, 0));
  for (int u = 0; u < n; u++) {
    vector<int> &vl = p2l[u];
    int nvl = int(vl.size());
    for (int ivl = 0; ivl < nvl; ivl++) {
      int l = vl[ivl];
      vector<int> &vu = l2p[l];
      int nvu = int(vu.size());
      for (int ivu = 0; ivu < nvu; ivu++) {
        int v = vu[ivu];
        m[v][u] += 1.0 / nvl / nvu;
      }
    }
  }
  vm[0] = m;
  for (int steps = 1; steps < tope; steps++)
    vm[steps] = vm[steps - 1] * vm[steps - 1];
  int cases;
  cin >> cases;
  for (int cas = 0; cas < cases; cas++) {
    int p, t;
    cin >> p >> t;
    p--;
    t--;
    vector<double> V(n, 0);
    V[p] = 1;
    for (int b = 0; b < tope; b++)
      if (t & (1 << b)) V = V * vm[b];
    double sol = 0;
    vector<int> vl = p2l[p];
    int nvl = int(vl.size());
    for (int ivl = 0; ivl < nvl; ivl++) {
      int l = vl[ivl];
      double pl = 0;
      vector<int> &vu = l2p[l];
      int nvu = int(vu.size());
      for (int ivu = 0; ivu < nvu; ivu++) {
        int v = vu[ivu];
        pl += 1.0 / nvu * V[v];
      }
      maximize(sol, pl);
    }
    cout << sol << endl;
  }
}