#include<stdio.h>
#include<stdlib.h>
#include<memory.h>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>

using namespace std;

    FILE *f, *g;
    int a[20001], b[20001], c[20001];
    int n;

    int gde[20001];//gde smo trenutno dodelili taj(korisno za da znamo da li je dodat)
    int igde[2001];//na njemu pise koji je na tom polju
    //kad

    struct medo
    {
        int idx, cena;//koji je medo u pitanju, i koliko kosta
        bool operator <(medo x)const
        {
            return cena < x.cena;
        }

    };

    priority_queue <medo> tren;//ovde ce cuvamo sve mede koji su trenutno nedodati

    vector<medo> start[2001];//cuva listu koji pocinju u tom
    vector<medo> end[2001];//cuva listu kojih se zavrsavaju tu


    struct cvor
    {
        priority_queue <medo> a;
    };

    cvor seg[10001];

    void dodaj(medo x, int target, int t, int l, int d)//t je trenutni indeks, target medino mesto
    {
        if(l>d) return;//kraj rekurzije

        if(target>=l&&target<=d)//ovaj interval je medin
        {
            seg[t].a.push(x);
            if(l<d)
            {
            dodaj(x,target, t*2, l, (l+d)/2 );
            dodaj(x,target, t*2+1, (l+d)/2+1, d);
            }
        }
        else return;

    }

    int minn, imin;//kada se vadi najjeftini dodati sa datog intervala, ovde se upamti njegova cena i koji je u pitanju(idx)

    void get_min(int t, int l1, int d1, int l, int d)//pretrazujemo [l,d]
    {
        if(l1>d1) return;//nevalidan cvor
        if(l>d1||d<l1) return;//nema preklapanja

        if(l1>=l&&d1<=d)//kompletno preklapanje
        {
            if(seg[t].a.top().cena<minn) { minn = seg[t].a.top().cena; imin = seg[t].a.top().idx; }
            return;
        }

        get_min(2*t, l1, (l1+d1)/2, l, d);
        get_min(2*t+1,(l1+d1)/2+1, d1, l, d);

    }

    void remove_min(int idx, int t, int l, int d)//u idx stavimo imin
    {
        if(l>d) return;//kraj rekurzije

        if(idx>=l&&idx<=d)//ovaj interval je medin
        {
            seg[t].a.pop();//izbacili smo tog medu, jer on je minimum
            remove_min(idx, t*2, l, (l+d)/2);
            remove_min(idx, t*2+1, (l+d)/2+1, d);
        }
        else return;


    }


    long long total = 0;//ukupna cena

int main()//UKUPNA CENA MORA BITI LONG LONG LONG LONG LONG LONG LONG!!!!!!!!
{
    f = fopen("mede.in","r");
    g = fopen("mede.out","w");
    fscanf(f,"%d",&n);

    medo pomm;
    for(int i = 1; i <= 20000; i++) gde[i] = -1;//nijedan nije dodeljen

    for(int i = 1; i <= n; i++)
    {
        fscanf(f,"%d %d %d",&a[i],&b[i],&c[i]);
        pomm.cena = c[i];
        pomm.idx = i;
        start[a[i]].push_back(pomm);//i-ti meda tu pocinje
        end[b[i]].push_back(pomm);
        total+=c[i];
    }
    //mogli bi po ceni sortirati start i end
    for(int i = 1; i <= 2000; i++)
    {
        igde[i] = -1;//da je prazan

        if(start[i].size()!=0) sort(&start[i][0], &start[i][start[i].size()]);
        //sortiranje za start nije ni bitno, jer im svima radimo isto - dodajemo ih u hip
        //za end, pak, moramo prvo vaditi one koji su SIROMASNIJI!!!!!!
        if(end[i].size()!=0) sort(&end[i][0], &end[i][end[i].size()]);

    }
    //
//  printf("taf");
    medo px2;//pomocni

    for(int i = 1; i <= 2000; i++)
    {
          //printf("taf");
        //prvo vidimo sve koji se zavrsavaju tu, a nisu dodeljeni
        //jednostavno, probamo da ih dodamo, tj vidimo da li je u njihovoj jurisdikciji dodat neki manji od njih samih, ako jeste
        //vadimo ga, njegov gde ode u pm, i dodamo ovaj na njegovo mesto, ubacimo ga u segmentno, stavimo mu gde na dato mesto
        //Ako je izbaceni jos uvek aktuelan, treba ga ubaciti u hip na kraju ovog izvrsavanja
        //i tako iteriramo kroz sve koji se tu zavrsavaju, prvo treba pokusati dodati one bogatije
        //posto onima koji tu pocinju tu moze biti i kraj, PRVO U HIP dodamo sve koji tu pocinju, jer su oni onda ekvivalentni ostalima, oni su
        //tu u razmatranju
        //Jos je fora kada vadimo iz hipa, da one koji su dodeljeni, samo izbacimo, jer su mozda dodati na njihovom endu, pa su u hipu ostali dzabe
        //dakle, prvo sve koji pocinju u hip, onda jedan iz hipa napolje na ovo mesto, pa onda gledanje da li ima popravki

        for(int j = 0; j < start[i].size(); j++)
        {
            tren.push(start[i][j]);
        }

                 // printf("taf");


        if(!tren.empty())
        {
            //ovde treba da vadimo prvo sve koji vise ne odgovaraju
            while(!tren.empty()&&b[tren.top().idx]<i) tren.pop();

            if(!tren.empty())
            {
            pomm = tren.top();
            tren.pop();
            gde[pomm.idx] = i;
            igde[i] = pomm.idx;
            dodaj(pomm, i, 1, 1, 2000);
            }
        }//dakle, dodali smo novi, i to najjeftiniji

                //  printf("taf");


        for(int j = 0; j < end[i].size(); j++)//idemo od najsiromasnijih
        {
            if(gde[end[i][j].idx]==-1)//znaci da nije dodeljen
            {
            //onda trazimo min na njegovoj jurisdikciji
                px2=end[i][j];
                minn = 2000000000, imin = 0;
                get_min(1,1,2000,a[px2.idx], i);
                if(minn<px2.cena)
                {
                    //ovo znaci da vadimo minn, i da dodajemo ovaj
                    remove_min(imin, 1, 1, 2000);//sada, ukoliko je ovaj minimalni jos uvek moguce koristiti, treba ga vratiti u tren(hip)
                    dodaj(px2, imin, 1, 1, 2000);
                    int izbmedo = igde[i];//kog smo medu izbacili
                    gde[izbmedo] = -1;//on vise nema mesto

                    gde[px2.idx] = i;
                    igde[i] = px2.idx;//sada smo ovog medu dodali

                    if(b[izbmedo]>i)
                    {//ovo je ako ovaj meda jos moze biti dodat
                    px2.idx = izbmedo;
                    px2.cena = c[izbmedo];//sada je u px2 izbaceni medo
                    tren.push(px2);
                    }
                }

            }
        }


    }

    for(int i = 1; i <= 2000; i++) { if(igde[i]!=-1) { total-=c[igde[i]]; } }

    fprintf(g,"%lld\n",total);



}
