#include <fstream>
#include <algorithm>

using namespace std;

ifstream fin ("stalpi.in");
ofstream fout ("stalpi.out");

const int N = 1e2 + 5;
const int start = 131071;

struct stalp	{
	int x, c, st, dr;
} a[N];

struct interval	 {
	int st, dr, c;
} v[N];

int n;
long long k;
long long A[2 * start + 5], dp[start + 5];

int bs(int x, bool flag)	{
	int st = 1, dr = n, mij, ans = 0;
	if (flag && a[n].x <= x)
		return n;
	if (!flag && a[1].x >= x)
		return 1;
	while (st <= dr)	{
		mij = (st + dr) / 2;
		if (flag)	 {
			if (a[mij].x <= x)	 {
				ans = mij;
				st = mij + 1;
			} else
				dr = mij - 1;
		} else	{
			if (a[mij].x >= x)	{
				ans = mij;
				dr = mij - 1;
			} else
				st = mij + 1;
		}
	}
	return ans;
}

bool cmp(stalp _x, stalp _y)	{
	return _x.x < _y.x;
}

bool cmp2(interval _x, interval _y)	 {
	return _x.dr < _y.dr || _x.dr == _y.dr && _x.st < _y.st;
}

void Update(int nod)	 {
	A[nod] = min(A[nod * 2], A[nod * 2 + 1]);
	if (nod > 1)
		Update(nod / 2);
}

long long Query(int st, int dr)	 {
	long long ans = 1e12;
	if (st & 1)	 {
		ans = min(ans, A[st]);
		++st;
	}
	if (!(dr & 1))	{
		ans = min(ans, A[dr]);
		--dr;
	}
	if (st > dr)
		return ans;
	if (st == dr)
		return min(ans, A[st]);
	long long aux = Query(st / 2, dr / 2);
	return min(ans, aux);
}

int main()	{
	fin >> n;
	for (int i = start + 1; i <= start + start + 1; ++i)
		A[i] = 1e12;
	for (int i = 1; i <= n; ++i)
		fin >> a[i].x >> a[i].c >> a[i].st >> a[i].dr;
	sort (a + 1, a + n + 1, cmp);
	for (int i = 1; i <= n; ++i)	{
		v[i].st = bs(a[i].x - a[i].st, 0);
		v[i].dr = bs(a[i].x + a[i].dr, 1);
		v[i].c = a[i].c;
	}
	sort (v + 1, v + n + 1, cmp2);
//	for (int i = 1; i <= n; ++i)	{
//		fout << v[i].st << ' ' << v[i].dr << ' ' << v[i].c << '\n';
//	}
	for (int i = 1; i <= start + 1; ++i)	{
		dp[i] = 1e12;
		A[i + start] = 1e12;
		if (!(i & 1))
			Update((i + start) / 2);
	}
	for (int i = 1; i <= n; ++i)	{
		if (v[i].st == 1)
			k = 0;
		else
			k = Query(v[i].st - 1 + start, n + start);
		dp[v[i].dr] = min(k + v[i].c, dp[v[i].dr]);
		A[v[i].dr + start] = dp[v[i].dr];
		Update((v[i].dr + start) / 2);
	}
//	for (int i = 1; i <= n; ++i)	{
//		fout << dp[i] << ' ';
//	}
	fout << dp[n];
	return 0;
}