#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 << ")";
    }
};

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

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

    auto combine(const array<ld, 6> &lhs, const array<ld, 6> &rhs) {
        array<ld, 6> res{};
        res[3] = rhs[3] + lhs[3];
        res[2] = max(rhs[2], rhs[3] + lhs[2]);
        res[1] = max(lhs[1], lhs[3] + rhs[1]);
        res[4] = max(lhs[4], lhs[3] + rhs[4]);
        res[5] = max(rhs[5], rhs[3] + lhs[5]);
        res[0] = max({lhs[0], rhs[0], rhs[4] + lhs[5]});
        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;
            s[v][4] = val - 2 * all[l].first;
            s[v][5] = val + 2 * all[l].first;
            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]);
    }

};

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);
    int n;
    cin >> n;
    vector<Point<ll>> a(n);
    vector<ll> w(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i].x >> a[i].y >> w[i];
    }
    ld res{0};
    for (int i = 0; i < n; ++i) {
        auto v = a;
        for (auto &x: v)x = x - a[i];
        Point<ld> A(v[i]);
        for (int j = i + 1; j < n; ++j) {
            Point<ld> B(v[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(v[k]);
                    if ((inv ? -1 : 1) * v[j].cross(v[k]) >= 0) {
                        auto z = lineProj(A, B, C);
                        all.emplace_back(z.dist() * ((v[j]).dot(v[k]) < 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;
}