#include "bits/stdc++.h"

#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second

using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};

ll mod(ll a, ll mod){
  ll res = a%mod;
  if(res<0)res=res + mod;
  return res;
}

ll modpow(ll a, ll n, ll mod){
  ll res=1;
  while(n>0){
    if(n&1) res=res*a%mod;
    a=a*a%mod;
    n>>=1;
  }
  return res;
}

ll modinv(ll a, ll mod){
  ll b=mod, u=1, v=0;
  while(b){
    ll t=a/b;
    a-=t*b; swap(a, b);
    u-=t*v; swap(u, v);
  }
  u%=mod;
  if(u<0)u+=mod;
  return u;
}

ll gcd(ll a, ll b){
  ll r = a%b;
  if(r==0) return b;
  else return gcd(b, a%b);
}

bool is_prime(ll n){
  ll i = 2;
  if(n==1)return false;
  if(n==2)return true;
  bool res = true;
  while(i*i <n){
    if(n%i==0){
      res = false;
    }
    i = i+1;
  }

  //if(i==1)res = false;
  if(n%i==0)res=false;
  return res;
}

struct UnionFind{
  ll N;
  llvec p;
  llvec cnt;
  UnionFind(ll n){
    N = n;
    p=llvec(N);
    cnt=llvec(N, 0);
    rep(i, N){
      p[i] = i;
      cnt[i] = 1;
    }
  }

  void con(ll a, ll b){
    P at = root(a);
    P bt = root(b);
    if(at.second!=bt.second){
      if(at.first>bt.first){
        swap(at, bt);
        swap(a, b);
      }
      p[at.second] = bt.second;
      cnt[bt.second]+=cnt[at.second];
      p[a]=bt.second;
    }
  }

  P root(ll a){
    ll atmp = a;
    ll c=0;
    while(atmp!=p[atmp]){
      atmp = p[atmp];
      c++;
    }
    p[a] = atmp;
    return {c, atmp};
  }

  bool is_con(ll a, ll b){
    P at=root(a);
    P bt=root(b);
    return at.second == bt.second;
  }
  
};


/**************************************
** A main function starts from here  **
***************************************/
int main(){
  ll N;
  cin >> N;
  llvec x(N), y(N);
  rep(i, N)cin >> x[i]>>y[i];

  ld ok = 1e-10;
  ld ng = 300;
  while(abs(ok-ng)>1e-9){
    ld r= (ok+ng)*0.5;
    UnionFind uf(N+2);
    for(ll i=0;i<N;i++){
      for(ll j=i+1;j<N;j++){
        if(sqrt(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2)) <2 * r){
          uf.con(i, j);
        }
      }
      
      if(abs(y[i]-100)<2*r)uf.con(N, i);
      if(abs(y[i]+100)<2*r)uf.con(N+1, i);
    }
    if(uf.is_con(N, N+1)){
      ng=r;
    }else{
      ok=r;
    }
    
  }

  cout << setprecision(15)<<ok;

  
  
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()

const long long MOD = 1000000007;
struct mint {
    long long int value;

    mint() : value(0) {}

    explicit mint(long long int value) : value((value % MOD + MOD) % MOD) {}

    mint &fix() {
        value = (value % MOD + MOD) % MOD;
        return *this;
    }

    mint operator-() const { return mint(0) - *this; }

    mint operator~() const { return mint(1) / *this; }

    mint &operator+=(const mint &others) {
        if ((value += others.value) >= MOD) value -= MOD;
        return *this;
    }

    mint &operator-=(const mint &others) {
        if ((value += MOD - others.value) >= MOD) value -= MOD;
        return *this;
    }

    mint &operator*=(const mint &others) {
        (value *= others.value) %= MOD;
        return *this;
    }

    mint &operator/=(const mint &others) {
        (value *= others.pow(MOD - 2).value) %= MOD;
        return *this;
    }

    mint operator+(const mint &a) const { return mint(*this) += a; }

    mint operator-(const mint &a) const { return mint(*this) -= a; }

    mint operator*(const mint &a) const { return mint(*this) *= a; }

    mint operator/(const mint &a) const { return mint(*this) /= a; }

    mint pow(long long int t) const {
        if (!t) return mint(1);
        mint res = pow(t / 2);
        res *= res;
        return (t & 1) ? res * mint(value) : res;
    }

    bool operator<(const mint &a) const { return value < a.value; }

    bool operator<=(const mint &a) const { return value <= a.value; }

    bool operator>(const mint &a) const { return value > a.value; }

    bool operator>=(const mint &a) const { return value >= a.value; }

    bool operator==(const mint &a) const { return value == a.value; }
};

mint ex(mint x, long long int t) {
    return x.pow(t);
}

std::istream &operator>>(std::istream &i, mint &a) {
    i >> a.value;
    return i;
}

std::ostream &operator<<(std::ostream &o, const mint &a) {
    o << a.value;
    return o;
}

void solve(long long N, std::vector<long long> A){
    sort(all(A));
    vector<ll> a = {0};
    a.insert(a.end(), all(A));
    mint ans = mint(1);
    rep(i, N) {
        ans *= mint(a.at(i + 1) - a.at(i) + 1);
    }
    cout << ans << endl;
}

int main(){
    long long N;
    scanf("%lld",&N);
    std::vector<long long> A(N);
    for(int i = 0 ; i < N ; i++){
        scanf("%lld",&A[i]);
    }
    solve(N, std::move(A));
    return 0;
}
