#include<iostream>
#include<cstring>
#include<vector>
#include<iomanip>
#include<array>
using namespace std;
using LL = long long;

#include<iostream>
#include<cstring>
#include<deque>
#include<cassert>
#include<algorithm>
using namespace std;
using LL = long long;

template <typename T, bool isMin>
struct ConvexHullTrickAddMonotone{
#define F first
#define S second
    using P = pair<T, T>;
    deque<P> H;

    ConvexHullTrickAddMonotone() = default;

    bool empty() const { return H.empty(); }

    void clear() { H.clear(); }

    inline int sgn(T x) { return x == 0 ? 0 : (x < 0 ? -1 : 1); }

    inline bool check(const P &a, const P &b, const P &c){
        if (b.S == a.S || c.S == b.S)
            return sgn(b.F - a.F) * sgn(c.S - b.S) >= sgn(c.F - b.F) * sgn(b.S - a.S);
        // return (b.F-a.F)*(c.S-b.S) >= (b.S-a.S)*(c.F-b.F);
        if (is_integral<T>::value){
            return __int128_t(c.S - b.S) * sgn(c.F - b.F) * abs(b.F - a.F) >= 
			       __int128_t(b.S - a.S) * sgn(b.F - a.F) * abs(c.F - b.F);
            // return (b.S - a.S) / (a.F - b.F) >= (c.S - b.S) / (b.F - c.F);
        }
        else{
            return (b.F - a.F) * sgn(c.S - b.S) / abs(b.S - a.S) >=
                   (c.F - b.F) * sgn(b.S - a.S) / abs(c.S - b.S);
        }
    }

    void add(T a, T b){
        if (!isMin)
            a *= -1, b *= -1;
        P line(a, b);
        if (empty()){
            H.emplace_front(line);
            return;
        }
        if (H.front().F <= a){
            if (H.front().F == a){
                if (H.front().S <= b)
                    return;
                H.pop_front();
            }
            while (H.size() >= 2 && check(line, H.front(), H[1]))
                H.pop_front();
            H.emplace_front(line);
        }
        else{
            assert(a <= H.back().F);
            if (H.back().F == a){
                if (H.back().S <= b)
                    return;
                H.pop_back();
            }
            while (H.size() >= 2 && check(H[H.size() - 2], H.back(), line))
                H.pop_back();
            H.emplace_back(line);
        }
    }

    inline T get_y(const P &a, const T &x){
        return a.F * x + a.S;
    }

    T query(T x){
        assert(!empty());
        int l = -1, r = H.size() - 1;
        while (l + 1 < r){
            int m = (l + r) >> 1;
            if (get_y(H[m], x) >= get_y(H[m + 1], x))
                l = m;
            else
                r = m;
        }
        if (isMin)
            return get_y(H[r], x);
        return -get_y(H[r], x);
    }

    T query_monotone_inc(T x){
        assert(!empty());
        while (H.size() >= 2 && get_y(H.front(), x) >= get_y(H[1], x))
            H.pop_front();
        if (isMin)
            return get_y(H.front(), x);
        return -get_y(H.front(), x);
    }

    T query_monotone_dec(T x){
        assert(!empty());
        while (H.size() >= 2 && get_y(H.back(), x) >= get_y(H[H.size() - 2], x))
            H.pop_back();
        if (isMin)
            return get_y(H.back(), x);
        return -get_y(H.back(), x);
    }

#undef F
#undef S
};

template<typename T> 
struct Map{
    vector<T> nums;

    Map() {}

    void add(T x){
        nums.push_back(x);
    }

    void build(){
        sort(nums.begin(), nums.end());
        nums.erase(unique(nums.begin(), nums.end()), nums.end());
    }

    int get(T x){
        return int(lower_bound(nums.begin(), nums.end(), x) - nums.begin()) + 1;
    }

    T val(int x){
        return nums[x - 1];
    }

    int size(){
        return (int)nums.size();
    }
};

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);
    cout << fixed << setprecision(20);

    int n;
    cin >> n;
    Map<int> mp;
    mp.add(1);
    vector<array<int, 3> > p(n);
    for(int i = 0; i < n; i++){
        int a, b, x;
        cin >> a >> b >> x;
        mp.add(a);
        mp.add(b);
        p[i] = {a, b, x};
    }
    mp.build();
    LL ans = -5e18;
    const int m = mp.size();
    vector<LL> s(m + 1);
    for(auto [a, b, x] : p){
        a = mp.get(a);
        b = mp.get(b);
        s[a] += x;
        s[b] += x;
    }
    for(int i = 1; i <= m; i++){
        s[i] += s[i - 1];
    }
    for(int i = 1; i <= m; i++){
        s[i] -= s[m] - s[i];
    }

    ConvexHullTrickAddMonotone<LL, false> CHT;

    for(int i = 1; i <= m; i++){
        CHT.add(-4 * mp.val(i), s[i]);
        ans = max(ans, CHT.query_monotone_inc(mp.val(i)) + s[i]);
    }
    cout << ans / 4.0 << '\n';

}