#include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef long long db;
const db EPS = 0;

inline int sign(db a) { return a < -EPS ? -1 : a > EPS; }

inline int cmp(db a, db b) { return sign(a - b); }

struct P
{
    db x, y;
    P() {}
    P(db _x, db _y) : x(_x), y(_y) {}
    P operator+(P p) { return {x + p.x, y + p.y}; }
    P operator-(P p) { return {x - p.x, y - p.y}; }
    P operator*(db d) { return {x * d, y * d}; }
    P operator/(db d) { return {x / d, y / d}; }

    bool operator<(P p) const
    {
        int c = cmp(x, p.x);
        if (c)
            return c == -1;
        return cmp(y, p.y) == -1;
    }

    bool operator==(P o) const
    {
        return cmp(x, o.x) == 0 && cmp(y, o.y) == 0;
    }

    db dot(P p) { return x * p.x + y * p.y; }
    db det(P p) { return x * p.y - y * p.x; }

    db dsitTo(P p) { return (*this - p).abs(); }
    db alpha() { return atan2(y, x); }
    void read() { cin >> x >> y; }
    void write() { cout << "(" << x << "," << y << ")" << endl; }
    db abs() { return sqrt(abs2()); }
    db abs2() { return x * x + y * y; }
    P rot90() { return P(-y, x); }
    P unit() { return *this / abs(); }
    // 判断点在(0,pi)还是(-pi,0),用于极角排序
    int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
    P rot(db an) { return {x * cos(an) - y * sin(an), x * sin(an) + y * cos(an)}; }
};

#define cross(p1, p2, p3) ((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y))
#define crossOp(p1, p2, p3) sign(cross(p1, p2, p3))

// 直线p1p2, q1q2 是否恰有一个交点
bool chkLL(P p1, P p2, P q1, P q2)
{
    db a1 = cross(q1, q2, p1);
    db a2 = -cross(q1, q2, p2);
    return sign(a1 + a2) != 0;
}
// 直线p1p2, q1q2 的交点
P isLL(P p1, P p2, P q1, P q2)
{
    db a1 = cross(q1, q2, p1);
    db a2 = -cross(q1, q2, p2);
    return (p1 * a2 + p2 * a1) / (a1 + a2);
}

bool intersect(db l1, db r1, db l2, db r2)
{
    if (l1 > r1)
        swap(l1, r1);
    if (l2 > r2)
        swap(l2, r2);
    return !(cmp(r1, l2) == -1 || cmp(r2, l1) == -1);
}

// 线段 p1p2, q1q2 相交
bool isSS(P p1, P p2, P q1, P q2)
{
    return intersect(p1.x, p2.x, q1.x, q2.x) && intersect(p1.y, p2.y, q1.y, q2.y) &&
           crossOp(p1, p2, q1) * crossOp(p1, p2, q2) <= 0 && crossOp(q1, q2, p1) * crossOp(q1, q2, p2) <= 0;
}
// 线段 p1p2, q1q2 严格相交(交点不会在端点)
bool isSS_strict(P p1, P p2, P q1, P q2)
{
    return crossOp(p1, p2, q1) * crossOp(p1, p2, q2) < 0 && crossOp(q1, q2, p1) * crossOp(q1, q2, p2) < 0;
}
// m是否在ab上
bool isMiddle(db a, db m, db b)
{
    // if (a > b) swap(a, b);
    // return cmp(a, m) <= 0 && cmp(m, b) <= 0;
    return sign(a - m) == 0 || sign(b - m) == 0 || (a < m != b < m);
}

bool isMiddle(P a, P m, P b)
{
    return isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
}

// 点 p 在线段 p1p2 上
bool onSeg(P p1, P p2, P q)
{
    // crossOp精度问题严重，如果确定q，p1，p2三点共线，那么直接isMiddle判断
    return crossOp(p1, p2, q) == 0 && isMiddle(p1, q, p2);
}
// 点 p y严格在线段 p1p2 上
bool onSeg_strict(P p1, P p2, P q)
{
    return crossOp(p1, p2, q) == 0 && sign((q - p1).dot(p1 - p2)) * sign((q - p2).dot(p1 - p2)) < 0;
}

// q 在直线 p1p2 上的垂足（投影坐标) 注意：p1 != p2
P proj(P p1, P p2, P q)
{
    P dir = p2 - p1;
    return p1 + dir * (dir.dot(q - p1) / dir.abs2());
}

// 以 p1p2 为轴 对点 q 进行反射
P reflect(P p1, P p2, P q)
{
    return proj(p1, p2, q) * 2 - q;
}

// 求 q 到线段 p1p2 的最小距离
db nearest(P p1, P p2, P q)
{
    if (p1 == p2)
        return p1.dsitTo(q);
    P h = proj(p1, p2, q);
    if (isMiddle(p1, h, p2))
        return q.dsitTo(h);
    return min(p1.dsitTo(q), p2.dsitTo(q));
}

// 求线段 p1p2 与线段 q1q2 的距离
db disSS(P p1, P p2, P q1, P q2)
{
    if (isSS(p1, p2, q1, q2))
        return 0;
    return min(min(nearest(p1, p2, q1), nearest(p1, p2, q2)), min(nearest(q1, q2, p1), nearest(q1, q2, p2)));
}

// 极角排序
// sort(p, p + n, [&]( P &a,  P &b)
//      { int qa = a.quad(), qb = b.quad();
//      if (qa != qb) return qa < qb;
//      else return sign(a.det(b)) > 0; });
const int N = 2010;
ll ans;
int n;
P p[N][2];
pair<P, ll> evt[2 * N];
ll solve(P o)
{
    int t = 0;
    for (int i = 1; i <= n; i++)
    {
        // 同一y值不看
        if (p[i][0].y == o.y)
            continue;
        // 左端点
        P p1 = p[i][0] - o;
        // 右端点，极角序一定小于左端点链接出的向量
        P p2 = p[i][1] - o;
        int len = p[i][1].x - p[i][0].x;
        if (p[i][1].y > o.y)
        {
            // 扫描进入
            evt[t++] = {p2, len};
            // 扫描退出
            evt[t++] = {p1, -len};
        }
        // 考虑360度的直线旋转，将所有向量转化到一个半区内,这样相当于统计另一个半区时，把射线延长为直线
        else
        {
            // 扫描进入
            evt[t++] = {p1 * (-1), len};
            // 扫描退出
            evt[t++] = {p2 * (-1), -len};
        }
    }
    sort(evt, evt + t, [&](pair<P, ll> &a, pair<P, ll> &b)
         {
        auto d = a.first.det(b.first);
        if (d != 0) return d > 0; 
        // 卡端点，先加后减
        else return a.second > b.second; });
    ll res = 0;
    ll cur = 0;
    for (int i = 0; i < t; i++)
    {
        cur += evt[i].second;
        res = max(res, cur);
    }
    return res;
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        int x1, x2, y;
        scanf("%d %d %d", &x1, &x2, &y);
        if (x1 > x2)
        {
            swap(x1, x2);
        }
        p[i][0] = P(x1, y);
        p[i][1] = P(x2, y);
    }
    // 对每个点端点扫描一遍
    for (int i = 1; i <= n; i++)
    {
        // 做的时候不考虑本线段的长度,最后加上
        ans = max(ans, max(solve(p[i][0]), solve(p[i][1])) + p[i][1].x - p[i][0].x);
    }
    cout << ans << endl;
    return 0;
}