Problem: Gena doesn't like geometry, so he asks you to solve this problem for him.

A rectangle with sides parallel to coordinate axes contains n dots. Let's consider some point of the plane. Let's count the distances from this point to the given n points. Let's sort these numbers in the non-decreasing order. We'll call the beauty of the point the second element of this array. If there are two mimimum elements in this array, the beaty will be equal to this minimum.

Find the maximum beauty of a point inside the given rectangle.

Input

The first line contains three integers w, h, n (1 ≤ w, h ≤ 106, 2 ≤ n ≤ 1000) — the lengths of the rectangle sides and the number of points. Next n lines contain two integers xi, yi (0 ≤ xi ≤ w, 0 ≤ yi ≤ h) each — the coordinates of a point. It is possible that it will be coincident points.

Output

Print a single number — the maximum beauty of a point with the absolute or relative error of at most 10 - 9.

Examples

Input

5 5 4
0 0
5 0
0 5
5 5


Output

4.99999999941792340


Input

5 5 3
4 0
2 5
4 1


Output

5.65685424744772010

Note

The point which beauty we need to find must have coordinates (x, y), where 0 ≤ x ≤ w, 0 ≤ y ≤ h. Some of the n points can coincide.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
template <typename T>
std::istream &operator>>(std::istream &input, std::pair<T, T> &data) {
  input >> data.first >> data.second;
  return input;
}
template <typename T>
std::istream &operator>>(std::istream &input, std::vector<T> &data) {
  for (T &first : data) input >> first;
  return input;
}
template <typename T>
std::ostream &operator<<(std::ostream &output, const pair<T, T> &data) {
  output << "(" << data.first << "," << data.second << ")";
  return output;
}
template <typename T>
std::ostream &operator<<(std::ostream &output, const std::vector<T> &data) {
  for (const T &first : data) output << first << " ";
  return output;
}
std::ostream &operator<<(std::ostream &output, const __int128 &first) {
  __int128 n = first;
  if (n == 0) {
    output << "0";
    return output;
  }
  if (n < 0) {
    n = -n;
    output << "-";
  }
  string s;
  while (n) {
    s += '0' + (n % 10);
    n /= 10;
  }
  reverse(s.begin(), s.end());
  cout << s;
  return output;
}
long long div_up(long long a, long long b) {
  return a / b + ((a ^ b) > 0 && a % b);
}
long long div_down(long long a, long long b) {
  return a / b - ((a ^ b) < 0 && a % b);
}
long long math_mod(long long a, long long b) { return a - b * div_down(a, b); }
template <class T>
using V = vector<T>;
template <class T>
bool ckmin(T &a, const T &b) {
  return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T &a, const T &b) {
  return a < b ? a = b, 1 : 0;
}
long long gcd(long long a, long long b) {
  while (b) {
    tie(a, b) = make_pair(b, a % b);
  }
  return a;
}
long long Bit(long long mask, long long bit) { return (mask >> bit) & 1; }
const long double PI = 4 * atan(1.);
const long double eps = 1e-10;
bool eq(long double first, long double second) {
  return abs(first - second) < eps;
}
bool ls(long double first, long double second) {
  return first < second && !eq(first, second);
}
bool lseq(long double first, long double second) {
  return first < second || eq(first, second);
}
long long sgn(long double first) {
  if (eq(first, 0)) return 0;
  if (first > 0)
    return 1;
  else
    return -1;
}
long double sqr(long double first) { return first * first; }
long double readLD() {
  double first;
  scanf("%lf", &first);
  return first;
}
struct Point {
  long double first, second;
  Point() : first(), second() {}
  Point(long double _x, long double _y) : first(_x), second(_y) {}
  void scan() {
    first = readLD();
    second = readLD();
  }
  void print() { printf("%.13lf %.13lf\n", (double)first, (double)second); }
  Point operator+(const Point &a) const {
    return Point(first + a.first, second + a.second);
  }
  Point operator-(const Point &a) const {
    return Point(first - a.first, second - a.second);
  }
  Point operator*(const long double &k) const {
    return Point(first * k, second * k);
  }
  Point operator/(const long double &k) const {
    return Point(first / k, second / k);
  }
  long double operator%(const Point &a) const {
    return first * a.first + second * a.second;
  }
  long double operator*(const Point &a) const {
    return first * a.second - second * a.first;
  }
  long double sqrLen() const { return *this % *this; }
  long double len() const { return sqrtl(sqrLen()); }
  Point norm() const { return *this / len(); }
  Point ort() const { return Point(-second, first); }
  Point rot(const long double &ca, const long double &sa) const {
    return *this * ca + ort() * sa;
  }
  Point rot(const long double &ang) const { return rot(cosl(ang), sinl(ang)); }
  bool operator==(const Point &a) const {
    return eq(first, a.first) && eq(second, a.second);
  }
  bool operator<(const Point &a) const {
    if (!eq(first, a.first)) return first < a.first;
    return ls(second, a.second);
  }
};
long double getAngle(Point v, Point u) { return atan2l(v * u, v % u); }
bool onLine(Point A, Point B, Point C) { return eq((A - B) * (A - C), 0); }
bool onSegm(Point A, Point B, Point C) { return lseq((A - B) % (C - B), 0); }
bool intersectLines(Point A, Point a, Point B, Point b, Point &I) {
  if (eq(a * b, 0)) return false;
  long double second = ((A - B) * a) / (b * a);
  I = B + b * second;
  return true;
}
Point getH(Point P, Point A, Point a) {
  return A + a * (((P - A) % a) / a.sqrLen());
}
bool intersectLineCircle(Point A, Point a, Point O, long double R, Point &I1,
                         Point &I2) {
  Point H = getH(O, A, a);
  long double h = (O - H).len();
  if (ls(R, h)) return false;
  if (eq(R, h)) {
    I1 = I2 = H;
    return true;
  }
  long double first = sqrtl(sqr(R) - sqr(h));
  a = a.norm();
  I1 = H + a * first;
  I2 = H - a * first;
  return true;
}
bool intersectCircles(Point O1, long double R1, Point O2, long double R2,
                      Point &I1, Point &I2) {
  if (R1 < R2) {
    swap(R1, R2);
    swap(O1, O2);
  }
  long double L = (O1 - O2).len();
  if (ls(R1 + R2, L) || ls(L, R1 - R2) || eq(L, 0)) return false;
  if (eq(R1 + R2, L) || eq(L, R1 - R2)) {
    I1 = I2 = O1 + (O2 - O1).norm() * R1;
    return true;
  }
  long double first = (sqr(L) + sqr(R1) - sqr(R2)) / (2 * L);
  Point a = (O2 - O1).norm();
  Point H = O1 + a * first;
  a = a.ort() * sqrtl(sqr(R1) - sqr(first));
  I1 = H + a;
  I2 = H - a;
  return true;
}
bool insidePolygon(Point P, const vector<Point> &a) {
  for (long long i = 0; i < (long long)a.size() - 1; i++) {
    if (onLine(a[i], P, a[i + 1]) && onSegm(a[i], P, a[i + 1])) {
      return true;
    }
  }
  long double ang = 0;
  for (long long i = 0; i < (long long)a.size() - 1; i++)
    ang += getAngle(a[i] - P, a[i + 1] - P);
  return abs(ang) > 1;
}
long double polygonArea(const vector<Point> &a) {
  long double S = 0;
  for (long long i = 0; i < (long long)a.size() - 1; i++) S += a[i] * a[i + 1];
  return abs(S) / 2;
}
bool cmp(const Point &v, const Point &u) {
  long double first = v * u;
  if (!eq(first, 0)) return first > 0;
  return ls(v.sqrLen(), u.sqrLen());
}
vector<Point> graham(vector<Point> a) {
  Point minP = a[0];
  for (long long i = 0; i < (long long)a.size(); i++) {
    minP = min(minP, a[i]);
  }
  for (long long i = 0; i < (long long)a.size(); i++) a[i] = a[i] - minP;
  sort(a.begin(), a.end(), cmp);
  for (long long i = 0; i < (long long)a.size(); i++) a[i] = a[i] + minP;
  long long m = 0;
  for (Point P : a) {
    while (m > 2 && lseq(0, (P - a[m - 1]) * (P - a[m - 2]))) {
      m--;
    }
    a[m++] = P;
  }
  a.resize(m);
  return a;
}
bool tangentsFromPoint(Point P, Point O, long double R, Point &I1, Point &I2) {
  long double L = (P - O).len();
  if (lseq(L, R)) return false;
  long double ang = acosl(R / L);
  Point a = (P - O).norm() * R;
  I1 = O + a.rot(ang);
  I2 = O + a.rot(-ang);
  return true;
}
long double distPointSegment(Point A, Point P, Point Q) {
  Point H = getH(A, P, Q - P);
  if (onSegm(P, H, Q))
    return (A - H).len();
  else
    return min((A - P).len(), (A - Q).len());
}
bool onSameSide(Point P, Point Q, Point A, Point a) {
  return sgn(a * (P - A)) * sgn(a * (Q - A)) == 1;
}
bool intersectSegments(Point A, Point B, Point C, Point D) {
  if (eq(0, (A - B) * (C - D))) {
    if (!onLine(A, B, C)) return false;
    Point a = B - A;
    if (a == Point()) a = D - C;
    if (a == Point()) return A == C;
    long double l1 = A % a, r1 = B % a, l2 = C % a, r2 = D % a;
    if (l1 > r1) swap(l1, r1);
    if (l2 > r2) swap(l2, r2);
    return lseq(max(l1, l2), min(r1, r2));
  }
  return !onSameSide(A, B, C, D - C) && !onSameSide(C, D, A, B - A);
}
long double distSegments(Point A, Point B, Point C, Point D) {
  if (intersectSegments(A, B, C, D)) return 0;
  return min(min(distPointSegment(A, C, D), distPointSegment(B, C, D)),
             min(distPointSegment(C, A, B), distPointSegment(D, A, B)));
}
const long double EPS = 1e-10;
const long long N = 2207;
pair<long double, long long> sc[N];
long double dist[N][N], ang[N][N];
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  long long W, H, n;
  cin >> W >> H >> n;
  V<Point> a(n);
  for (long long i = (0); i < (n); ++i) {
    long long first, second;
    cin >> first >> second;
    a[i] = Point(first, second);
  }
  for (long long i = (0); i < (n); ++i) {
    for (long long j = (0); j < (n); ++j) {
      dist[i][j] = (a[j] - a[i]).len();
      ang[i][j] = atan2(a[j].second - a[i].second, a[j].first - a[i].first);
    }
  }
  auto check = [&](long long i, long double R) {
    long long sz = 0;
    long long cur = 0;
    auto Arc = [&](long double l, long double r, long long first) {
      if (r < l) {
        swap(l, r);
        cur += first;
        first = -first;
      }
      sc[sz++] = make_pair(l, first);
      sc[sz++] = make_pair(r + EPS, -first);
    };
    auto mod = [&](long double ang) {
      while (ang < -PI) {
        ang += 2 * PI;
      }
      while (ang > PI) {
        ang -= 2 * PI;
      }
      return ang;
    };
    for (long long j = (0); j < (n); ++j) {
      if (i == j) {
        continue;
      }
      if (a[i] == a[j]) {
        continue;
      }
      if (dist[i][j] < R * 2) {
        long double sh = acos(dist[i][j] / (2 * R));
        long double l = mod(ang[i][j] - sh);
        long double r = mod(ang[i][j] + sh);
        Arc(l, r, 1);
      }
    }
    if (a[i].first < R) {
      long double sh = acos(a[i].first / R);
      Arc(mod(-PI - sh), mod(-PI + sh), 2);
    }
    if (W - a[i].first < R) {
      long double sh = acos((W - a[i].first) / R);
      Arc(mod(-sh), mod(+sh), 2);
    }
    if (a[i].second < R) {
      long double sh = acos(a[i].second / R);
      Arc(mod(-PI / 2 - sh), mod(-PI / 2 + sh), 2);
    }
    if (H - a[i].second < R) {
      long double sh = acos((H - a[i].second) / R);
      Arc(mod(PI / 2 - sh), mod(PI / 2 + sh), 2);
    }
    sort(sc, sc + sz);
    if (cur < 2) {
      return 1;
    }
    for (long long i = (0); i < (sz); ++i) {
      cur += sc[i].second;
      if (cur < 2) {
        return 1;
      }
    }
    return 0;
  };
  vi ord(n);
  for (long long i = (0); i < (n); ++i) {
    ord[i] = i;
  }
  mt19937 rnd(2007);
  shuffle(ord.begin(), ord.end(), rnd);
  long double ans = 0;
  for (auto &i : ord) {
    if (check(i, ans + EPS)) {
      long double l = 0, r = W + H;
      for (long long _ = (0); _ < (60); ++_) {
        long double m = (l + r) / 2;
        if (check(i, m)) {
          l = m;
        } else {
          r = m;
        }
      }
      ans = l;
    }
  }
  cout.precision(20);
  cout << fixed << ans << '\n';
}