Problem: After a drawn-out mooclear arms race, Farmer John and the Mischievous Mess Makers have finally agreed to establish peace. They plan to divide the territory of Bovinia with a line passing through at least two of the n outposts scattered throughout the land. These outposts, remnants of the conflict, are located at the points (x1, y1), (x2, y2), ..., (xn, yn).

In order to find the optimal dividing line, Farmer John and Elsie have plotted a map of Bovinia on the coordinate plane. Farmer John's farm and the Mischievous Mess Makers' base are located at the points P = (a, 0) and Q = ( - a, 0), respectively. Because they seek a lasting peace, Farmer John and Elsie would like to minimize the maximum difference between the distances from any point on the line to P and Q.

Formally, define the difference of a line <image> relative to two points P and Q as the smallest real number d so that for all points X on line <image>, |PX - QX| ≤ d. (It is guaranteed that d exists and is unique.) They wish to find the line <image> passing through two distinct outposts (xi, yi) and (xj, yj) such that the difference of <image> relative to P and Q is minimized.

Input

The first line of the input contains two integers n and a (2 ≤ n ≤ 100 000, 1 ≤ a ≤ 10 000) — the number of outposts and the coordinates of the farm and the base, respectively.

The following n lines describe the locations of the outposts as pairs of integers (xi, yi) (|xi|, |yi| ≤ 10 000). These points are distinct from each other as well as from P and Q.

Output

Print a single real number—the difference of the optimal dividing line. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

2 5
1 0
2 1


Output

7.2111025509


Input

3 6
0 1
2 5
0 -3


Output

0.0000000000

Note

In the first sample case, the only possible line <image> is y = x - 1. It can be shown that the point X which maximizes |PX - QX| is (13, 12), with <image>, which is <image>.

In the second sample case, if we pick the points (0, 1) and (0, - 3), we get <image> as x = 0. Because PX = QX on this line, the minimum possible difference is 0.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(double(-1));
const double INF = 1e10;
const double EPS = 1e-8;
inline double sqr(double x) { return x * x; }
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  void in() { scanf("%lf%lf", &x, &y); }
};
bool operator<(const PT &p1, const PT &p2) {
  if (fabs(p1.x - p2.x) > EPS) return p1.x < p2.x;
  return p1.y + EPS < p2.y;
}
bool operator==(const PT &p1, const PT &p2) {
  return fabs(p1.x - p2.x) < EPS && fabs(p1.y - p2.y) < EPS;
}
PT operator+(PT p1, PT p2) { return PT(p1.x + p2.x, p1.y + p2.y); }
PT operator-(PT p1, PT p2) { return PT(p1.x - p2.x, p1.y - p2.y); }
PT operator*(PT p, double c) { return PT(p.x * c, p.y * c); }
PT operator/(PT p, double c) { return PT(p.x / c, p.y / c); }
double dis(PT p) { return sqrt(sqr(p.x) + sqr(p.y)); }
double dis2(PT p) { return sqr(p.x) + sqr(p.y); }
double dis2(PT p1, PT p2) { return sqr(p1.x - p2.x) + sqr(p1.y - p2.y); }
double dis(PT p1, PT p2) { return sqrt(dis2(p1, p2)); }
double vect(PT p1, PT p2) { return p1.x * p2.y - p2.x * p1.y; }
double scal(PT p1, PT p2) { return p1.x * p2.x + p1.y * p2.y; }
double getAngle(PT p) { return atan2(p.y, p.x); }
double vect(PT p, PT p1, PT p2) { return vect(p1 - p, p2 - p); }
double scal(PT p, PT p1, PT p2) { return scal(p1 - p, p2 - p); }
double getAngle(PT p, PT p1, PT p2) {
  return getAngle(p2 - p) - getAngle(p1 - p);
}
double getAngle180(PT p, PT p1, PT p2) {
  return acos(scal(p, p1, p2) / dis(p, p1) / dis(p, p2));
}
double disToLine(PT p, PT p1, PT p2) {
  return fabs(vect(p, p1, p2)) / dis(p1, p2);
}
double disToSeg(PT p, PT p1, PT p2) {
  if (scal(p1, p, p2) < 0) return dis(p, p1);
  if (scal(p2, p, p1) < 0) return dis(p, p2);
  return disToLine(p, p1, p2);
}
bool onLine(PT p, PT p1, PT p2) { return fabs(vect(p1 - p, p2 - p)) < EPS; }
bool onSeg(PT p, PT p1, PT p2) {
  if (!onLine(p, p1, p2)) return 0;
  return (p1.x - p.x) * (p2.x - p.x) < EPS && (p1.y - p.y) * (p2.y - p.y) < EPS;
}
PT projection(PT a, PT b, PT p) {
  return a + (a - b) * (scal(p - a, a - b) / dis2(a - b));
}
int posLineLine(PT p1, PT p2, PT p3, PT p4, PT &p) {
  double s1 = vect(p1, p2, p3), s2 = vect(p1, p2, p4);
  if (fabs(s1 - s2) < EPS) {
    if (fabs(s1) < EPS) return 2;
    return 0;
  }
  p = p3 + (p4 - p3) * s1 / (s1 - s2);
  return 1;
}
int posCirLine(PT p, double r, PT p1, PT p2, PT *q) {
  double a, b, c, d2, d;
  a = dis2(p1, p2);
  b = scal(p1, p, p2);
  c = dis2(p, p1) - sqr(r);
  d2 = sqr(b) - a * c;
  if (d2 < -EPS) return 0;
  d = sqrt(fabs(d2));
  q[0] = p1 + (p2 - p1) * (b + d) / a;
  q[1] = p1 + (p2 - p1) * (b - d) / a;
  if (d2 < EPS) return 1;
  return 2;
}
int posCirCir(PT p1, double r1, PT p2, double r2, PT *q) {
  double dx, dy, d, e, f2, f;
  dx = p2.x - p1.x, dy = p2.y - p1.y;
  d = dis(p1, p2);
  e = (sqr(r1) - sqr(r2) + sqr(d)) / 2 / d;
  f2 = sqr(r1) - sqr(e);
  if (f2 < -EPS) return 0;
  f = sqrt(fabs(f2));
  q[0] = PT(p1.x + (e * dx - f * dy) / d, p1.y + (e * dy + f * dx) / d);
  q[1] = PT(p1.x + (e * dx + f * dy) / d, p1.y + (e * dy - f * dx) / d);
  if (f2 < EPS) return 1;
  return 2;
}
double calcArea(PT *p, int n) {
  double rlt = 0;
  for (int i = 0; i < n; i++) rlt += vect(p[i], p[(i + 1) % n]);
  return rlt / 2;
}
int inPolygon(PT p, PT *q, int m) {
  PT p1, p2;
  int k = 0;
  for (int i = 0; i < m; i++) {
    p1 = q[i], p2 = q[(i + 1) % m];
    if (onSeg(p, p1, p2)) return 2;
    if (p1.y > p2.y) swap(p1, p2);
    if (p1.y < p.y + EPS && p.y + EPS < p2.y && vect(p, p1, p2) > 0) k++;
  }
  return k % 2;
}
int convex_hull(PT *p, int n, PT *q) {
  sort(p, p + n);
  n = unique(p, p + n) - p;
  if (n == 1) {
    q[0] = p[0];
    return 1;
  }
  int m = 0;
  for (int i = 0; i < n; i++) {
    while (m > 1 && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
    q[m++] = p[i];
  }
  int k = m;
  for (int i = n - 2; i >= 0; i--) {
    while (m > k && vect(q[m - 2], q[m - 1], p[i]) < EPS) m--;
    q[m++] = p[i];
  }
  return --m;
}
const int N = 110000;
PT P[N], Q[2];
int n;
double a;
PT A, B;
int flg[N];
bool can(double x) {
  vector<pair<double, int> > vec;
  for (int i = 0; i < n; i++)
    if (posCirCir(A, x, P[i], dis(P[i], B), Q))
      for (int j = 0; j < 2; j++)
        vec.push_back(pair<double, int>(getAngle(Q[j] - A), i));
  sort(vec.begin(), vec.end());
  memset(flg, 0, sizeof flg);
  int cnt = 0;
  vector<int> sta;
  for (auto &t : vec) {
    int u = t.second;
    if (!flg[u])
      sta.push_back(u), flg[u] = 1;
    else {
      if (sta.back() != u) return 1;
      sta.pop_back();
    }
  }
  return 0;
}
int main() {
  scanf("%d%lf", &n, &a);
  A = PT(-a, 0), B = PT(a, 0);
  for (int i = 0; i < n; i++) P[i].in();
  double st = 0, en = a * 2;
  for (int times = 0; times < 100; times++) {
    double md = (st + en) / 2;
    if (can(md))
      en = md;
    else
      st = md;
  }
  printf("%.10lf\n", st);
}