#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long read() {
  long long x = 0;
  bool q = 0;
  char c = getchar();
  while (!isdigit(c)) q |= (c == '-'), c = getchar();
  while (isdigit(c)) x = (x << 1) + (x << 3) + c - '0', c = getchar();
  return q ? -x : x;
}
void print(long long x, char q = '\n') {
  if (x < 0) putchar('-'), x = -x;
  if (x == 0) putchar('0');
  stack<char> s;
  s.push(q);
  while (x > 0) s.push(x % 10 + '0'), x /= 10;
  while (!s.empty()) putchar(s.top()), s.pop();
}
string read_s() {
  string s;
  char c = getchar();
  while (c == ' ' || c == '\t' || c == '\n') c = getchar();
  while (c != ' ' && c != '\t' && c != '\n') s += c, c = getchar();
  return s;
}
void print_s(string s, char q = '\n') {
  for (char c : s) putchar(c);
  putchar(q);
}
char read_c() {
  char c = getchar();
  while (c == ' ' || c == '\t' || c == '\n') c = getchar();
  return c;
}
const long double eps = 1e-12;
bool equal(long double x, long double y) { return x - eps < y && y < x + eps; }
struct Point {
  long double x, y;
  Point() {}
  Point(long double x, long double y) : x(x), y(y) {}
  Point operator+(const Point &t) const { return Point(x + t.x, y + t.y); }
  Point operator-(const Point &t) const { return Point(x - t.x, y - t.y); }
  Point operator*(const long double &t) { return Point(x * t, y * t); }
  long double operator*(const Point &t) const { return x * t.x + y * t.y; }
  Point operator/(const long double &t) const { return Point(x / t, y / t); }
  bool operator<(const Point &t) const {
    return fabs(x - t.x) < eps ? y < t.y : x < t.x;
  }
  bool operator==(const Point &t) const {
    return equal(x, t.x) && equal(y, t.y);
  }
  long double dist2() const { return x * x + y * y; }
  long double dist() const { return sqrt(dist2()); }
  Point rot90() const { return Point(-y, x); }
  Point rot(double t) const {
    return Point(x * cos(t) - y * sin(t), x * sin(t) + y * cos(t));
  }
  Point ProyInLine(const Point &a, const Point &b) const {
    return a + (b - a) * (((*this) - a) * (b - a)) / (b - a).dist2();
  }
  Point ProyInSeg(const Point &a, const Point &b) const {
    if ((b - a).dist2() < eps) return a;
    long double r = (((*this) - a) * (b - a)) / (b - a).dist2();
    if (r < 0) return a;
    if (r > 1) return b;
    return a + (b - a) * r;
  }
};
long double X, Y;
struct Bisector {
  long double A, B, C, ang, hyp;
  int id;
  Bisector(long double A, long double B, long double C, long double hyp)
      : A(A), B(B), C(C), hyp(hyp) {
    ang = atan2(A, B);
    id = -1;
  }
  Bisector(Point a, Point b, int id) : id(id) {
    Point mid = (a + b) * 0.5;
    A = b.x - a.x;
    B = b.y - a.y;
    C = -A * mid.x - B * mid.y;
    ang = atan2(A, B);
    hyp = hypot(A, B);
  }
  bool operator^(Bisector L) {
    long double det = A * L.B - L.A * B;
    X = -(C * L.B - B * L.C) / det, Y = (C * L.A - A * L.C) / det;
    return !equal(det, 0);
  }
};
bool operator<(const Bisector &a, const Bisector &b) {
  return equal(a.ang, b.ang) ? (b.hyp + eps < a.hyp) : (a.ang + eps < b.ang);
}
bool bad(Bisector a, Bisector b, Bisector c) {
  a ^ b;
  return c.A * X + c.B * Y + c.C > eps;
}
deque<Bisector> ConvexHull(vector<Bisector> bs) {
  sort(bs.begin(), bs.end());
  deque<Bisector> stk;
  for (auto u : bs) {
    while (!stk.empty() && equal(u.ang, stk.back().ang)) stk.pop_back();
    while (stk.size() > 1 && bad(stk[stk.size() - 2], stk.back(), u))
      stk.pop_back();
    stk.push_back(u);
  }
  bool q = 1;
  while (q) {
    q = 0;
    while (stk.size() > 2 && bad(stk[1], stk[0], stk.back()))
      stk.pop_front(), q = 1;
    while (stk.size() > 2 && bad(stk.back(), stk[stk.size() - 2], stk[0]))
      stk.pop_back(), q = 1;
  }
  return stk;
}
int W, H;
vector<Bisector> build(vector<Point> &p, int x) {
  vector<Bisector> ret;
  for (int i = 0; i < p.size(); i++)
    if (i != x) ret.push_back(Bisector(p[x], p[i], i));
  ret.push_back(Bisector(-1, 0, 0, 2 * p[x].x));
  ret.push_back(Bisector(0, -1, 0, 2 * p[x].y));
  ret.push_back(Bisector(1, 0, -W, 2 * W - 2 * p[x].x));
  ret.push_back(Bisector(0, 1, -H, 2 * H - 2 * p[x].y));
  return ret;
}
void Voronoi(vector<Point> &p, vector<Point> &ans) {
  int n = p.size();
  for (int i = 0; i < n; i++) {
    deque<Bisector> v = ConvexHull(build(p, i));
    for (int j = 1; j < v.size(); j++)
      if (v[j - 1] ^ v[j]) ans.push_back(Point(X, Y));
    if (v.back() ^ v[0]) ans.push_back(Point(X, Y));
  }
}
int main() {
  W = read(), H = read();
  int n = read();
  vector<Point> p(n), candi;
  for (int i = 0; i < n; i++) p[i].x = read(), p[i].y = read();
  for (int i = 0; i < n; i++) {
    deque<Bisector> v = ConvexHull(build(p, i));
    vector<Point> q;
    for (auto u : v)
      if (u.id != -1) q.push_back(p[u.id]);
    Voronoi(q, candi);
  }
  long double ans = 0;
  sort(candi.begin(), candi.end());
  candi.resize(unique(candi.begin(), candi.end()) - candi.begin());
  for (auto u : candi) {
    long double f = 1e18, g = 1e18;
    for (auto v : p) {
      long double x = (u - v).dist2();
      if (x < f)
        g = f, f = x;
      else if (x < g)
        g = x;
    }
    ans = max(ans, g);
  }
  ans = sqrt(ans);
  printf("%.17f\n", (double)ans);
}
