/* imports all std modules {{{*/
import
  std.algorithm,
  std.array,
  std.ascii,
  std.base64,
  std.bigint,
  std.bitmanip,
  std.compiler,
  std.complex,
  std.concurrency,
  std.container,
  std.conv,
  std.csv,
  std.datetime,
  std.demangle,
  std.encoding,
  std.exception,
  std.file,
  std.format,
  std.functional,
  std.getopt,
  std.json,
  std.math,
  std.mathspecial,
  std.meta,
  std.mmfile,
  std.net.curl,
  std.net.isemail,
  std.numeric,
  std.parallelism,
  std.path,
  std.process,
  std.random,
  std.range,
  std.regex,
  std.signals,
  std.socket,
  std.stdint,
  std.stdio,
  std.string,
  std.system,
  std.traits,
  std.typecons,
  std.uni,
  std.uri,
  std.utf,
  std.uuid,
  std.variant,
  std.zip,
  std.zlib;
/*}}}*/

/* libnum {{{*/
void amax(N, Args...)(ref N x, Args y) {
  x = x.max(y);
}
void amin(N, Args...)(ref N x, Args y) {
  x = x.min(y);
}
auto maxE(R)(R r) if (isInputRange!R) {
  ElementType!R x = r.front;
  r.popFront();
  foreach (y; r) x.amax(y);
  return x;
}
auto minE(R)(R r) if (isInputRange!R) {
  ElementType!R x = r.front;
  r.popFront();
  foreach (y; r) x.amin(y);
  return x;
}
/*}}}*/

/+---test
2
0 0
1 0
---+/
/+---test
3
0 0
0 1
1 0
---+/
/+---test
10
10 9
5 9
2 0
0 0
2 7
3 3
2 5
10 0
3 7
1 9
---+/

void main(string[] args) {
  const N = readln.chomp.to!long;

  auto pt = new long[][](N, 2);
  foreach (ref p; pt) {
    readf(" %d %d ", &p[0], &p[1]);
  }

  double nans = 0;
  foreach (i; 0..N) foreach (j; i+1..N) {
    nans.amax(((pt[i][0]-pt[j][0]).pow(2)+(pt[i][1]-pt[j][1]).pow(2)).to!double.sqrt/2);
  }

  double ans = 1e+10;
  foreach (i; 0..N) foreach (j; i+1..N) foreach (k; j+1..N) {
    const p0 = pt[i];
    const p1 = pt[j];
    const p2 = pt[k];

    const A = 2*(p1[0]-p0[0]);
    const B = 2*(p1[1]-p0[1]);
    const C = -p0[0].pow(2) + p1[0].pow(2) - p0[1].pow(2) + p1[1].pow(2);
    const D = 2*(p2[0]-p1[0]);
    const E = 2*(p2[1]-p1[1]);
    const F = -p1[0].pow(2) + p2[0].pow(2) - p1[1].pow(2) + p2[1].pow(2);

    const a = (C*E - B*F)*1. / (A*E - B*D);
    const b = (A*F - D*C)*1. / (A*E - B*D);
    const r = (p0[0] - a).pow(2) + (p0[1] - b).pow(2);

    const r2 = r*r;

    bool ok = true;
    foreach (l; 0..N) {
      if ((pt[l][0]-a).pow(2) + (pt[l][1]-b).pow(2) > r2) {
        ok = false;
        break;
      }
    }
    if (ok) {
      ans.amin(r);
    }
  }
  "%10f".writefln(min(nans, ans));
}
