#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>

using namespace std;

struct Point {
  double x, y, z;
  Point() : x(), y(), z() {}
  Point(double xx, double yy, double zz) : x(xx), y(yy), z(zz) {}
  double norm() const {
    return sqrt(norm2());
  }
  double norm2() const {
    return x * x + y * y+ z * z;
  }

  Point& operator +=(const Point& b) {
    x += b.x;
    y += b.y;
    z += b.z;
    return *this;
  }
  Point& operator -=(const Point& b) {
    x -= b.x;
    y -= b.y;
    z -= b.z;
    return *this;
  }
  Point& operator *=(double b) {
    x *= b;
    y *= b;
    z *= b;
    return *this;
  }
  Point& operator /=(double b) {
    x /= b;
    y /= b;
    z /= b;
    return *this;
  }
  Point operator +(const Point& b) const {
    return Point(x+b.x, y+b.y, z+b.z);
  }
  Point operator -(const Point& b) const {
    return Point(x-b.x, y-b.y, z-b.z);
  }
  Point operator *(double b) const {
    return Point(x*b, y*b, z*b);
  }
  Point operator /(double b) const {
    return Point(x/b, y/b, z/b);
  }
};

double Dist(const Point& a, const Point& b) {
  return (a - b).norm();
}

double Dot(const Point& a, const Point& b) {
  return a.x * b.x + a.y * b.y + a.z * b.z;
}

Point Cross(const Point& a, const Point& b) {
  return Point(a.y * b.z - a.z * b.y,
	       a.z * b.x - a.x * b.z,
	       a.x * b.y - a.y * b.x);
}

void Check(const Point& c, double d);

double OuterCircle(const Point& p1, const Point& p2, const Point& p3,
		   Point& c, Point& h) {
  h = Cross(p2 - p1, p3 - p1);
  h /= h.norm();
  Point a = (p1 + p2) / 2;
  Point b = (p1 + p3) / 2;
  c = b - a;
  Point u = Cross(p2 - p1, h);
  Point v = Cross(p3 - p1, h);
  double s;
  if(u.x * v.y - u.y * v.x != 0)
    s = (c.x * v.y - c.y * v.x) / (u.x * v.y - u.y * v.x);
  else if(u.y * v.z - u.z * v.y != 0)
    s = (c.y * v.z - c.z * v.y) / (u.y * v.z - u.z * v.y);
  else if(u.z * v.x - u.x * v.z != 0)
    s = (c.z * v.x - c.x * v.z) / (u.z * v.x - u.x * v.z);
  else
    return -1.0;
  c = a + u * s;
  double d = (c - p1).norm();
  Check(c, d);
  return d;
}

void OuterSphere(const Point& c, const Point& h, double d, const Point& p) {
  if(Dot(c - p, h) == 0)
    return;
  double t = (d*d + 2 * Dot(p, c) - p.norm2() - c.norm2())
    / (2 * Dot(c - p, h));
  Point cc = c + h * t;
  double dd = sqrt(t*t + d*d);
  Check(cc, dd);
}

int n;
Point p[32];
double ans;

void Check(const Point& c, double d) {
  const double e = 0.000001;
  for(int i = 0; i < n; ++i)
    if((p[i] - c).norm() > d+e)
      return;
  ans = min(ans, d);
}

int main() {
  while(cin >> n && n) {
    ans = 10000000.0;
    for(int i = 0; i < n; ++i)
      cin >> p[i].x >> p[i].y >> p[i].z;
    for(int i = 0; i < n; ++i) {
      for(int j = i+1; j < n; ++j) {
	Check((p[i] + p[j]) / 2, ((p[i] - p[j]) / 2).norm());
	for(int k = j+1; k < n; ++k) {
	  Point c, h;
	  double d = OuterCircle(p[i], p[j], p[k], c, h);
	  if(d < 0) continue;
	  for(int l = k+1; l < n; ++l) {
	    OuterSphere(c, h, d, p[l]);
	  }
	}
      }
    }
    char val[100];
    sprintf(val, "%.5f", ans);
    cout << val << endl;
  }
}