#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = double;


template<class T>
int sgn(T x) { return (x > 0) - (x < 0); }

template<class T>
struct Point {
    typedef Point P;
    T x, y;

    explicit Point(T x = 0, T y = 0) : x(x), y(y) {}

    template<typename U>
    explicit Point(Point<U> o) : x(o.x), y(o.y) {};

    bool operator<(P p) const { return tie(x, y) < tie(p.x, p.y); }

    bool operator==(P p) const { return tie(x, y) == tie(p.x, p.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 cross(P a, P b) const { return (a - *this).cross(b - *this); }

    T dist2() const { return x * x + y * y; }

    ld dist() const { return sqrtl(dist2()); }

    P unit() const { return *this / dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees

    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a));
    }

    friend ostream &operator<<(ostream &os, P p) {
        return os << "(" << p.x << "," << p.y << ")";
    }
};

constexpr ld INF = 1e14 + 123;

struct s_tr {
    const vector<pair<ld, int>> &all;
    vector<array<ld, 4>> s;

    s_tr(const vector<pair<ld, int>> &all) : all(all) {
        ll n = all.size();
        s.resize(4 * n, array<ld, 4>{0, 0, 0, 0});
    }

    ld len(int pos) {
        return all[pos].first - all[pos - 1].first;
    }

    auto combine(const array<ld, 4> &lhs, const array<ld, 4> &rhs, int m) {
        array<ld, 4> res{};
        ld l = -2 * len(m);
        res[3] = rhs[3] + lhs[3] + l;
        res[2] = max(rhs[2], rhs[3] + lhs[2] + l);
        res[1] = max(lhs[1], lhs[3] + rhs[1] + l);
        res[0] = max({lhs[0], rhs[0], l + rhs[1] + lhs[2]});
        return res;
    }

    void upd(int v, int l, int r, int k, ld val) {
        if (l + 1 == r) {
            s[v][3] = s[v][2] = s[v][1] = s[v][0] = val;
            return;
        }
        int m = (r + l) / 2;
        if (k < m)upd(v * 2 + 1, l, m, k, val);
        else upd(v * 2 + 2, m, r, k, val);
        s[v] = combine(s[v * 2 + 1], s[v * 2 + 2], m);
    }

};

template<typename P>
P lineProj(P a, P b, P p, bool refl = false) {
    P v = b - a;
    return p - v.perp() * (1 + refl) * v.cross(p - a) / v.dist2();
}

int main() {
    cin.tie(0)->sync_with_stdio(false);
    mt19937 rng{1000 - 7};
    int n = 400;
    cin >> n;
    vector<Point<ll>> a(n);
    vector<ll> w(n);
    for (int i = 0; i < n; ++i) {
        a[i].x = rng() % (int) 1e6;
        a[i].y = rng() % (int) 1e6;
        w[i] = rng() % (int) 1e9;
        cin >> a[i].x >> a[i].y >> w[i];
    }
    ld res{0};
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            Point<ld> A(a[i]);
            Point<ld> B(a[j]);
            auto solve = [&](bool inv) {
                vector<pair<ld, ll>> points;
                vector<pair<ld, int>> all;
                for (int k = 0; k < n; ++k) {
                    Point<ld> C(a[k]);
                    if ((inv ? -1 : 1) * (a[j] - a[i]).cross(a[k] - a[i]) >= 0) {
                        auto z = lineProj(A, B, C);
                        all.emplace_back((z - A).dist() * ((a[j] - a[i]).dot(a[k] - a[i]) < 0 ? -1 : 1), k);
                        points.push_back({(z - C).dist(), k});
                    }
                }
                sort(all.begin(), all.end());
                vector<int> pos(n);
                for (int j = 0; j < all.size(); ++j) {
                    pos[all[j].second] = j;
                }
                sort(points.begin(), points.end());
                int N = all.size();
                s_tr tree(all);
                for (auto [d, k]: points) {
                    int p = pos[k];
                    tree.upd(0, 0, N, p, w[k]);
                    res = max(res, -2 * d + tree.s[0][0]);
                }
            };
            solve(false);
            solve(true);
        }
    }
    cout << fixed << setprecision(20);
    cout << res;
}