#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define rep(i,a,b) for(int i = a; i < (b); i++)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define sz(x) (int)(x).size()
#define PB push_back
#define FS first
#define SD second
#define cmx(x, y) x = max(x, y)
#define cmn(x, y) x = min(x, y)
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct Point3D {
    typedef Point3D P;
    typedef const P& R;
    T x, y, z;
    Point3D(T _x=0, T _y=0, T _z=0) : x(_x), y(_y), z(_z) {}
    P operator+(R p) const  { return P(x+p.x, y+p.y, z+p.y); }
    P operator-(R p) const  { return P(x-p.x, y-p.y, z-p.z); }
    P operator*(T d) const  { return P(x*d, y*d, z*d); }
    P operator/(T d) const  { return P(x/d, y/d, z/d); }
    T dot(R p) const { return x*p.x + y*p.y + z*p.z; }
    P cross(R p) const { return P(y*p.z-z*p.y, z*p.x-x*p.z, x*p.y-y*p.x); }
    T dist() const { return sqrtl(x*x+y*y+z*z); }
    P unit() const { return *this / dist(); }
    friend ostream& operator<<(ostream& os, P p) {
        return os << "(" << p.x << "," << p.y << "," << p.z << ")";
    }
};

Point3D<long double> conv(Point3D<int> p) {
    return Point3D<long double>(p.x, p.y, p.z);
}

typedef Point3D<int> P3;

struct PR {
    void ins(int x) { (a == -1 ? a : b) = x; }
    void rem(int x) { (a == x ? a : b) = -1; }
    int cnt() { return (a != -1) + (b != -1); }
    int a, b;
};

struct F { P3 q; int a, b, c; };

vector<F> hull3d(const vector<P3> &A) {
    assert(sz(A) >= 4);
    vector<vector<PR>> E(sz(A), vector<PR>(sz(A), {-1, -1}));
#define E(x, y) E[f.x][f.y]
    vector<F> FS;
    auto mf = [&](int i, int j, int k, int l) {
        P3 q = (A[j] - A[i]).cross((A[k] - A[i]));
        if (q.dot(A[l]) > q.dot(A[i]))
            q = q * -1;
        F f{q, i, j, k};
        E(a,b).ins(k); E(a,c).ins(j); E(b,c).ins(i);
        FS.push_back(f);
    };
    rep(i,0,4) rep(j,i+1,4) rep(k,j+1,4)
        mf(i,j,k,6-i-j-k);
    rep(i,4,sz(A)) {
        rep(j,0,sz(FS)) {
            F f = FS[j];
            if (f.q.dot(A[i]) > f.q.dot(A[f.a])) {
                E(a,b).rem(f.c);
                E(a,c).rem(f.b);
                E(b,c).rem(f.a);
                swap(FS[j--], FS.back());
                FS.pop_back();
            }
        }
        int nw = sz(FS);
        rep(j,0,nw) {
            F f = FS[j];
#define C(a,b,c) if (E(a,b).cnt() != 2) mf(f.a, f.b, i,f.c);
            C(a,b,c); C(a,c,b); C(b,c,a);
        }
    }
    for (F &it : FS) if ((A[it.b] - A[it.a]).cross(A[it.c] - A[it.a]).dot(it.q) <= 0) swap(it.c, it.b);
    return FS;
};

template<class T>
struct Point {
    typedef Point P;
    T x, y;
    Point(T _x=0, T _y=0) : x(_x), y(_y) {}
    P operator+(P p) const  { return P(x+p.x, y+p.y); }
    P operator-(P p) const  { return P(x-p.x, y-p.y); }
    P operator*(T d) const  { return P(x*d, y*d); }
    P operator/(T d) const  { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x, y*p.y; }
    T cross(P p) const { return x*p.y-y*p.x; }
    T dist2() const { return x*x+y*y; }
    long double dist() const { return sqrtl((long double)dist2()); }
    P perp() const { return P(-y, x); }
    P unit() const { return *this / dist(); }
};

typedef Point<long double> P;
P ccCenter(const P& A, const P& B, const P &C) {
    P b = C-A, c = B-A;
    return A + (b*c.dist2()-c*b.dist2()).perp()/b.cross(c)/2;
}

pair<P, long double> mec(vector<P> ps) {
    shuffle(all(ps), mt19937(time(0)));
    P o = ps[0];
    long double r = 0, EPS = 1+1e-8;
    rep(i,0,sz(ps)) if ((o-ps[i]).dist() > r*EPS) {
        o = ps[i], r = 0;
        rep(j, 0, i) if ((o-ps[j]).dist() > r * EPS) {
            o = (ps[i] + ps[j]) / 2;
            r = (o - ps[i]).dist();
            rep(k,0,j) if ((o-ps[k]).dist() > r*EPS) {
                o = ccCenter(ps[i], ps[j], ps[k]);
                r = (o - ps[i]).dist();
            }
        }
    }
    return {o, r};
}

typedef Point3D<long double> P3ld;
pair<long double, P3ld> normalize(P3ld base, P3ld v) {
    long double x = base.dot(v) / base.dot(base);
//    cerr << base << " " << v << " " << x << "d\n";
    return {x, v - base*x};
}

vector<P3> points;
long double licz(int p1, int p2, int p3) {
    P3ld a = conv(points[p2] - points[p1]).unit();
    P3ld b = conv(points[p3] - points[p1]);
    b = normalize(a, b).SD.unit();
    vector<P> pkts;
//    cerr << points[p1] << " " << points[p2] << " " << points[p3] << "\n";
//    cerr << a << " " << b << "\n";
    long double maxh = 0;
    for (int i = 0; i < sz(points); i++) {
        auto [x, left1] = normalize(a, conv(points[i] - points[p1]));
        auto [y, left2] = normalize(b, left1);
        cmx(maxh, left2.dist());
        pkts.PB({x, y});
//        cerr << points[i] << " " << x << " " << y << "xy\n";
    }
    long double r = mec(pkts).second;
//    cerr << p1 << " " << p2 << " " << p3 << " " << maxh << " " << r << "\n";
//    cerr << M_PI * r * r * maxh << "\n";
    return M_PI * r * r * maxh;
}

signed main() {
	cin.tie(0)->sync_with_stdio(0); cin.exceptions(cin.failbit);
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        int x, y, z;
        cin >> x >> y >> z;
        points.PB({x, y, z});
    }
    vector<F> hull = hull3d(points);
    long double best = 1e18;
    for (auto f : hull) {
//        cerr << "(" << f.q.x << ", " << f.q.y << ", " << f.q.z << ") " << f.a << " " << f.b << " " << f.c << "\n";
        long double pom = licz(f.a, f.b, f.c);
        cmn(best, pom);
    }
    cout << fixed << setprecision(10) << best << "\n";
}