#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


using Pt = pair<Int, Int>;
#define x first
#define y second

Int sq(Int r) {
  return r * r;
}

int N;
vector<Pt> P;

Int R2;
void check(const Pt &p, const Pt &q) {
  chmin(R2, sq(p.x - q.x) + sq(p.y - q.y));
}

vector<Pt> ps, qs;
void rec(int l, int r) {
  if (l + 1 < r) {
    const int m = (l + r) / 2;
    const Int xMid = P[m].x;
    rec(l, m);
    rec(m, r);
    const Int R = sqrt((long double)R2);
    int psLen = 0, qsLen = 0;
    for (int u = l; u < m; ++u) if (xMid - P[u].x < R) ps[psLen++] = P[u];
    for (int u = m; u < r; ++u) if (P[u].x - xMid < R) qs[qsLen++] = P[u];
    for (int i = 0, j0 = 0, j1 = 0; i < psLen; ++i) {
      for (; j0 < qsLen && qs[j0].y <= ps[i].y - R; ++j0) {}
      for (; j1 < qsLen && qs[j1].y <  ps[i].y + R; ++j1) {}
      for (int j = j0; j < j1; ++j) {
        check(ps[i], qs[j]);
      }
    }
    inplace_merge(P.begin() + l, P.begin() + m, P.begin() + r, [&](const Pt &p, const Pt &q) -> bool {
      return (p.y < q.y);
    });
  }
}

int main() {
  for (; ~scanf("%d", &N); ) {
    P.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%lld%lld", &P[u].x, &P[u].y);
    }
    
    // ?
    assert(N >= 2);
    
    sort(P.begin(), P.end());
    R2 = 9001001001001001001LL;
    ps.resize(N);
    qs.resize(N);
    rec(0, N);
    printf("%.15f\n", sqrt((double)R2));
  }
  return 0;
}