#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <iostream>

#include <queue>

#include <stack>

#include <vector>

#include <map>

#include <set>

#include <string>

#include <math.h>

#pragma warning(disable:4996)

#pragma comment(linker, "/STACK:1024000000,1024000000")

typedef long long LL;

using namespace std;

const int INF = <<;

const int N =  + ;

struct Node

{

    int to, dist, next;

    bool operator<(const Node&rhs)const

    {

        return dist < rhs.dist;

    }

}g[N];

int head[N], e;

int dist[N];

void addEdge(int a, int b, int c)

{

    g[e].to = b;

    g[e].dist = c;

    g[e].next = head[a];

    head[a] = e++;

}

int dij(int x, int y)

{

    priority_queue<Node> q;

    for (int i = x; i <= y; ++i)

        dist[i] = -INF;

    Node cur, tmp;

    dist[x] = cur.dist = ;

    cur.to = x;

    q.push(cur);

    while (!q.empty())

    {

        cur = q.top(); q.pop();

        int u = cur.to;

        if (dist[u] > cur.dist)

            continue;

        for (int i = head[u]; i != -; i = g[i].next)

        {

            int v = g[i].to;

            if (dist[v] < dist[u] + g[i].dist)

            {

                tmp.dist = dist[v] = dist[u] + g[i].dist;

                tmp.to = v;

                q.push(tmp);

            }

        }

    }

    return dist[y];

}

int main()

{

    int n, Min, Max, a, b, c;

    Node tmp;

    while (scanf("%d", &n) != EOF)

    {

        e = ;

        memset(head, -, sizeof(head));

        Min = INF, Max = -INF;

        for (int i = ; i <= n; ++i)

        {

            scanf("%d%d%d", &a, &b, &c);

            a++;

            b++;

            Min = min(a - , Min);

            Max = max(b, Max);

            addEdge(a - , b, c);

        }

        for (int i = Min+; i <= Max; ++i)

        {

            addEdge(i - , i, );

            addEdge(i, i - , -);

        }

        printf("%d\n", dij(Min, Max));

    }

    return ;

}