#include <bits/stdc++.h>

#define int long long

using namespace std;

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

const int nmax = 100000;

int n;
struct elem
{
    int x, cost;
    int st, dr;
};
elem v[nmax + 5];

bool cmp1(elem a, elem b)
{
    return a.x < b.x;
}

bool cmp2(elem a, elem b)
{
    return a.st < b.st;
}

int searchLeft(int val)
{
    int st = 1, dr = n;
    int r;
    while(st <= dr)
    {
        int mid = (st + dr) >> 1;
        if(v[mid].x >= val)
        {
            r = mid;
            dr = mid - 1;
        }
        else
        {
            st = mid + 1;
        }
    }
    return r;
}

int searchRight(int val)
{
    int st = 1, dr = n;
    int r = 1;
    while(st <= dr)
    {
        int mid = (st + dr) >> 1;
        if(v[mid].x <= val)
        {
            r = mid;
            st = mid + 1;
        }
        else
        {
            dr = mid - 1;
        }
    }
    return r;
}


int aint[4 * nmax + 5];
int lazy[4 * nmax + 5];

void updateLazy(int nod, int st, int dr, int l, int r, int val)
{
    if(st > dr)
    {
        return ;
    }
    if(st >= l && dr <= r)
    {
        aint[nod] = min(aint[nod], val);
        if(st != dr)
        {
            lazy[2 * nod] = min(lazy[2 * nod], val);
            lazy[2 * nod + 1] = min(lazy[2 * nod + 1], val);
        }
        return ;
    }
    if(st > r || dr < l)
    {
        if(st != dr)
        {
            lazy[2 * nod] = min(lazy[nod], lazy[2 * nod]);
            lazy[2 * nod + 1] = min(lazy[nod], lazy[2 * nod + 1]);
        }
        return ;
    }
    int mid = (st + dr) >> 1;
    if(r <= mid)
    {
        updateLazy(2 * nod, st, mid, l, r, val);
    }
    else
    {
        if(l > mid)
        {
            updateLazy(2 * nod + 1, mid + 1, dr, l, r, val);
        }
        else
        {
            updateLazy(2 * nod, st, mid, l, r, val);
            updateLazy(2 * nod + 1, mid + 1, dr, l, r, val);
        }
    }
}

int queryLazy(int nod, int st, int dr, int poz)
{
    if(st == dr)
    {
        return min(aint[nod], lazy[nod]);
    }
    else
    {
        lazy[2 * nod] = min(lazy[nod], lazy[2 * nod]);
        lazy[2 * nod + 1] = min(lazy[nod], lazy[2 * nod + 1]);
        int mid = (st + dr) >> 1;
        if(poz <= mid)
        {
            return queryLazy(2 * nod, st, mid, poz);
        }
        else
        {
            return queryLazy(2 * nod + 1, mid + 1, dr, poz);
        }
    }
}

signed main()
{
    fin >> n;
    for(int i = 1; i <= n; i ++)
    {
        fin >> v[i].x >> v[i].cost >> v[i].st >> v[i].dr;
    }
    sort(v + 1, v + n + 1, cmp1);
    for(int i = 1; i <= n; i ++)
    {
        v[i].st = searchLeft(v[i].x - v[i].st);
        v[i].dr = searchRight(v[i].x + v[i].dr);
    }
    sort(v + 1, v + n + 1, cmp2);

    for(int i = 1; i <= 4 * nmax; i ++)
    {
        aint[i] = 1e9;
        lazy[i] = 1e9;
    }

    for(int i = 1; i <= n; i ++)
    {
        if(v[i].st == 1)
        {
            updateLazy(1, 1, n, 1, v[i].dr, v[i].cost);
        }
        else
        {
            int cost = v[i].cost + queryLazy(1, 1, n, v[i].st - 1);
            updateLazy(1, 1, n, v[i].st, v[i].dr, cost);
        }
    }
    fout << queryLazy(1, 1, n, n) << '\n';
    return 0;
}