#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
int operator^(const complex<int> &a, const complex<int> &b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
bool cmp_xy(const complex<int> &a, const complex<int> &b) {
  if (a.real() == b.real()) {
    return a.imag() < b.imag();
  }
  return a.real() < b.real();
}
void hull_pass(vector<complex<int> > &p, vector<complex<int> > &S) {
  for (__typeof((p).begin()) it = (p).begin(); it != (p).end(); ++it) {
    while (((int)((S).size())) >= 2 &&
           ((S[((int)((S).size())) - 1] - S[((int)((S).size())) - 2]) ^
            (*it - S[((int)((S).size())) - 2])) >= 0) {
      S.pop_back();
    }
    S.push_back(*it);
  }
  S.pop_back();
}
void hull(const vector<complex<int> > &poly, vector<complex<int> > &res) {
  if (((int)((poly).size())) < 3) {
    res = poly;
    return;
  }
  vector<complex<int> > p = poly, S;
  hull_pass(p, S);
  res = S;
  S.clear();
  reverse((p).begin(), (p).end());
  hull_pass(p, S);
  res.insert(res.end(), (S).begin(), (S).end());
  reverse((res).begin(), (res).end());
}
int farthest(const vector<complex<int> > &P) {
  if (P.empty()) {
    return 0;
  }
  int a = 0, b = 0, n = ((int)((P).size()));
  for (int i = 0; i < (n); ++i) {
    if (P[i].imag() < P[a].imag() ||
        (P[i].imag() == P[a].imag() && P[i].real() > P[a].real())) {
      a = i;
    }
    if (P[i].imag() > P[b].imag() ||
        (P[i].imag() == P[b].imag() && P[i].real() < P[b].real())) {
      b = i;
    }
  }
  int res = 0;
  for (int f = 0; f < (n + 10); ++f) {
    res = max(res, norm(P[a] - P[b]));
    int na = (a + 1) % n, nb = (b + 1) % n;
    long long cr = (P[b] - P[nb]) ^ (P[na] - P[a]);
    if (cr > 0) {
      b = nb;
    } else {
      a = na;
      if (cr == 0) {
        b = nb;
      }
    }
  }
  return res;
}
vector<complex<int> > P;
bool check(int D) {
  vector<complex<int> > tmp, ch;
  tmp.reserve(((int)((P).size())));
  for (int i = 0; i < (((int)((P).size()))); ++i) {
    tmp.clear();
    for (int j = (i + 1); j < (((int)((P).size()))); ++j) {
      if (norm(P[i] - P[j]) >= D) {
        tmp.push_back(P[j]);
      }
    }
    hull(tmp, ch);
    if (farthest(ch) >= D) {
      return true;
    }
  }
  return false;
}
int main(void) {
  int n;
  scanf("%d", &n);
  P = vector<complex<int> >(n);
  for (int i = 0; i < (n); ++i) {
    int x, y;
    scanf("%d%d", &x, &y);
    P[i] = complex<int>(x, y);
  }
  sort((P).begin(), (P).end(), cmp_xy);
  int l = 0, r = 1000000000, best = 0;
  while (l <= r) {
    int mid = (l + r) / 2;
    if (check(mid)) {
      best = mid;
      l = mid + 1;
    } else {
      r = mid - 1;
    }
  }
  printf("%.20lf\n", 0.5 * sqrt(best));
  return 0;
}
