#include<bits/stdc++.h>
using namespace std;

const int eps = 1e-9;
inline bool iszero (double x) {
	return abs (x) <= eps;
}
inline bool eq (double x, double y) {
	return iszero (x - y);
}
inline int sign (double x) {
	if (iszero (x)) return 0;
	else return x > 0 ? 1 : -1;
}

struct vec {
	double x = 0, y = 0;
	vec () = default;
	vec (double px, double py): x(px), y(py) {
		
	} 
	vec (const vec &obj) {
		x = obj.x;
		y = obj.y;
	}
	
	vec operator + (vec b) const {return {x + b.x, y + b.y};} // Addition
	vec operator - (vec b) const {return {x - b.x, y - b.y};} // Subtraction
	vec operator - () const {return {-x, -y};} // Negation
	vec operator * (double k) const {return {x * k, y * k};} // Scalar multiplication
	double operator * (vec b) const {return x * b.x + y * b.y;} // Dot product
	
	double slope () {return y / x;}
};
double cross (vec a, vec b) { // Cross product
	return a.x * b.y - a.y * b.x;
}
bool parallel (vec a1, vec a2, vec b1, vec b2) { // checks if line A1A2 is parallel with B1B2
	return cross (a1 - a2, b1 - b2) == 0; 
}
bool intersect_sl (vec a, vec b, vec p, vec l) { // checks if segment AB intersects with the line on point P with the direction l
	double c1 = cross (p - a, l), c2 = cross (p - b, l);
	return sign (c1 * c2) != -1;
}
bool intersect_ss (vec a1, vec a2, vec b1, vec b2) { // checks if segment A1A2 intersects with B1B2
	double axl = min (a1.x, a2.x), axr = max (a1.x, a2.x), ayl = min (a1.y, a2.y), ayr = max (a1.y, a2.y);
	double bxl = min (b1.x, b2.x), bxr = max (b1.x, b2.x), byl = min (b1.y, b2.y), byr = max (b1.y, b2.y);
	if (sign (axr - bxl) == -1 || sign (axl - bxr) == 1 || sign (ayr - byl) == -1 || sign (ayl - byr) == 1) return false;
	
	return intersect_sl (a1, a2, b1, b1 - b2) && intersect_sl (b1, b2, a1, a1 - a2);
}

const int N = 2005;
int n;
struct node {
	int l, r, y;
} a[N];
struct event {
	double d;
	int t;
	bool operator < (event b) const {
		if (eq (d, b.d)) return t < b.t;
		else return d < b.d;
	}
} b[2 * N];
int main () {
	cin >> n;
	for (int i = 1;i <= n;i++) {
		cin >> a[i].l >> a[i].r >> a[i].y;
		if (a[i].l > a[i].r) swap (a[i].l, a[i].r);
 	}
	int ans = 0;
	for (int i = 1;i <= n;i++) {
		vec p (a[i].l, a[i].y);
		for (int j = 1;j <= n;j++) {
			if (i == j || a[i].y == a[j].y) {
				b[j * 2 - 1].t = b[j * 2].t = 0;
				continue;
			}
			vec q1 (a[j].l, a[j].y), q2 (a[j].r, a[j].y);
			double s1 = 1 / (p - q1).slope (), s2 = 1 / (p - q2).slope ();
			b[j * 2 - 1].d = min (s1, s2);
			b[j * 2 - 1].t = a[j].r - a[j].l;
			b[j * 2].d = max (s1, s2);
			b[j * 2].t = -a[j].r + a[j].l;
		}
		sort (b + 1, b + 2 * n + 1);
		int res = a[i].r - a[i].l;
		ans = max (ans, res);
		for (int j = 1;j <= 2 * n;j++) {
			res += b[j].t;
			ans = max (ans, res);
		}
	}
	cout << ans << endl;
	return 0;
}