#include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>

using namespace std;

const int MAXN = 1005;
vector<int> tedges[MAXN];
int discTime[MAXN];
bool visited[MAXN];
int low[MAXN];
int parv[MAXN];
int aptime;

bool dfsForAP(int curr, int parent) {
  visited[curr] = true;
  int numchild = 0;
  discTime[curr] = low[curr] = ++aptime;
  for(int out: tedges[curr]) {
    if(!visited[out]) {
      numchild++;
      parv[out] = curr;
      if(dfsForAP(out, curr)) return true;
      low[curr] = min(low[curr], low[out]);
      if((parent != -1 && low[out] >= discTime[curr])) {
        return true;
      }
    }
    else if(out != parv[curr]) {
      low[curr] = min(low[curr], discTime[out]);
    }
  }
  // if(parent == -1 && numchild > 1) return true;
  return false;
}

int main() {
  int n;
  cin >> n;
  n++;
  vector<array<int64_t, 2>> pts(n);
  for(int i = 1; i < n; i++) cin >> pts[i][0] >> pts[i][1];
  vector<array<int, 2>> edges;
  vector<vector<int64_t>> dist(n);
  for(int i = 0; i < n; i++) {
    dist[i].resize(n);
    for(int j = 0; j < n; j++) {
      int64_t x = pts[i][0] - pts[j][0];
      int64_t y = pts[i][1] - pts[j][1];
      dist[i][j] = x*x+y*y;
    }
  }
  for(int i = 0; i < n; i++) for(int j = i+1; j < n; j++) edges.push_back({i, j});
  sort(edges.begin(), edges.end(), [&](array<int, 2> a, array<int, 2> b) -> bool {
    return dist[a[0]][a[1]] < dist[b[0]][b[1]];
  });
  vector<int> needcheck(n-1);
  iota(needcheck.begin(), needcheck.end(), 1);
  int lhs = 0;
  int rhs = edges.size()-1;
  while(lhs < rhs) {
    int mid = (lhs+rhs)/2;
    aptime = 0;
    for(int i = 0; i < n; i++) {
      tedges[i].clear();
      visited[i] = false;
    }
    for(int a = 0; a <= mid; a++) {
      tedges[edges[a][0]].push_back(edges[a][1]);
      tedges[edges[a][1]].push_back(edges[a][0]);
    }
    bool bad = dfsForAP(0, -1);
    for(int i = 1; i < n; i++) bad = bad || !visited[i];
    if(bad) lhs = mid+1;
    else rhs = mid;
  }
  cout << fixed << setprecision(17) << sqrt(dist[edges[lhs][0]][edges[lhs][1]]) << "\n";
}