#include <fstream>
#include <algorithm>

using namespace std;

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

const long long max_size = 1e5 + 1, max_aint = 4e5 + 1, INF = 1e18 + 1;

struct str{
    long long x, st, dr, cost, lidx, ridx;
};

bool cmp1 (str x, str y)
{
    return x.x < y.x;
}

bool cmp2 (str x, str y)
{
    return x.lidx < y.lidx;
}

str v[max_size];
long long aint[max_aint], lazy[max_aint];

void push (long long nod, long long l, long long r)
{
    if (l != r)
    {
        lazy[2 * nod] = min(lazy[2 * nod], lazy[nod]);
        lazy[2 * nod + 1] = min(lazy[2 * nod + 1], lazy[nod]);
    }
    else
    {
        aint[nod] = min(aint[nod], lazy[nod]);
    }
    lazy[nod] = INF;
    return;
}

void upd (long long l, long long r, long long st, long long dr, long long val, long long nod)
{
    push(nod, l, r);
    if (st <= l && r <= dr)
    {
        lazy[nod] = val;
        return;
    }
    long long m = (l + r) / 2;
    if (st <= m)
    {
        upd(l, m, st, dr, val, 2 * nod);
    }
    if (dr > m)
    {
        upd(m + 1, r, st, dr, val, 2 * nod + 1);
    }
    /// e ff irelevant calcularea aintului, conteaza doar poz individuale
}

long long query (long long l, long long r, long long poz, long long nod)
{
    push(nod, l, r);
    if (l == r)
    {
        return aint[nod];
    }
    long long m = (l + r) / 2;
    if (poz <= m)
    {
        return query(l, m, poz, 2 * nod);
    }
    return query(m + 1, r, poz, 2 * nod + 1);
}

int main ()
{
    long long n;
    in >> n;
    for (long long i = 1; i <= n; i++)
    {
        in >> v[i].x >> v[i].st >> v[i].dr >> v[i].cost;
    }
    sort(v + 1, v + n + 1, cmp1);
    for (long long i = 1; i <= n; i++)
    {
        long long l = 1, r = i, aux = i;
        while (l <= r)
        {
            long long m = (l + r) / 2;
            if (v[m].x >= v[i].x - v[i].st)
            {
                aux = m;
                r = m - 1;
            }
            else
            {
                l = m + 1;
            }
        }
        v[i].lidx = aux;
        aux = i;
        l = i;
        r = n;
        while (l <= r)
        {
            long long m = (l + r) / 2;
            if (v[m].x <= v[i].x + v[i].dr)
            {
                aux = m;
                l = m + 1;
            }
            else
            {
                r = m - 1;
            }
        }
        v[i].ridx = aux;
    }
    sort(v + 1, v + n + 1, cmp2);
    for (long long i = 1; i <= 4 * n; i++)
    {
        aint[i] = INF;
        lazy[i] = INF;
    }
    for (long long i = 1; i <= n; i++)
    {
        long long aux;
        if (v[i].lidx == 1)
        {
            aux = v[i].cost;
        }
        else
        {
            aux = query(1, n, v[i].lidx - 1, 1) + v[i].cost;
        }
        upd(1, n, v[i].lidx, v[i].ridx, aux, 1);
    }
    out << query(1, n, n, 1);
    in.close();
    out.close();
    return 0;
}