#include <stdio.h>

#include <stdlib.h>



int mp = 0;





void max_profit(int events[][3], int used[], int n_events, int bd, int profit, int lta) {

	int i;

	int new_profit = profit;

	int new_lta = lta;

	for (i = 0; i < n_events; i++) {

		if (used[i])

			continue;

		used[i] = 1;

		if (lta + events[i][1] <= bd && lta + events[i][1] <= events[i][0]) {

			new_lta = lta + events[i][1];

			new_profit = profit + events[i][2];

			mp = max(mp, new_profit);

			max_profit(events, used, n_events, bd, new_profit, new_lta);

		}

		used[i] = 0;

	}

}





void swap(int* a, int* b)

{

    int t = *a;

    *a = *b;

    *b = t;

}



int min(int a , int b) {

	if (a < b)

		return a;

	return b;

}



int max(int a, int b) {

	if (a > b)

		return a;

	return b;

}



int partition (int arr[][3], int low, int high)

{

    int pivot = arr[high][0];    // pivot

    int i = (low - 1);  // Index of smaller element



    for (int j = low; j <= high- 1; j++)

    {

        // If current element is smaller than or

        // equal to pivot

        if (arr[j][0] <= pivot)

        {

            i++;    // increment index of smaller element

            swap(&arr[i][0], &arr[j][0]);

        }

    }

    swap(&arr[i + 1][0], &arr[high][0]);

    return (i + 1);

}



/* The main function that implements QuickSort

 arr[] --> Array to be sorted,

  low  --> Starting index,

  high  --> Ending index */

void quickSort(int arr[][3], int low, int high)

{

    if (low < high)

    {

        /* pi is partitioning index, arr[p] is now

           at right place */

        int pi = partition(arr, low, high);



        // Separately sort elements before

        // partition and after partition

        quickSort(arr, low, pi - 1);

        quickSort(arr, pi + 1, high);

    }

}



int algo(int n_events, int events[][3], int aux[][2], int max_dealine)

{



    int i, j, taux;



    printf("%d\n", max_dealine);



    for (j = 0; j <= n_events; j++)

    {

        aux[0][j] = 0;

    }



    for (i = 1; i <= max_dealine; i++)

    {



        aux[i][0] = 0;

    }



    for (i = 1; i <= n_events; i++)

    {



        for (j = 1; j <= max_dealine; j++)

        {



            taux = min(j, events[i][0]) - events[i][1];



            if (taux <= 0)

            {



                aux[i][j] = aux[i - 1][j];

            }

            else

            {



                aux[i][j] = max(aux[i - 1][j], events[i][2] + aux[i - 1][taux]);

            }

        }

    }

    printf("%d\n", aux[n_events][max_dealine]);



    //for (int i = 0; i < max_dealine; i++){

    	//for(j=0;i<n_events;j++){

    		//printf("%d\n", aux[i][j], aux[i][j]);

    	//}

    //}







    //max(T[i 􀀀 1; j ]; vi + T[i 􀀀 1; j 􀀀 wi ])



    return 0;

}



int main(int argc, char const *argv[]) {

	int i, n_events, bd = 0,maxi;





	while (scanf("%d", &n_events) > 0) {

		int events[n_events][3];

		for (i = 0; i < n_events; i++)

			scanf("%d %d %d", &events[i][0], &events[i][1], &events[i][2]);



		quickSort(events, 0, n_events-1);

		int max_dealine=events[n_events-1][0];

		int aux[n_events][max_dealine];

		//printf("saddsadsa\n");

    	maxi=algo(n_events,events,aux,max_dealine);

    	/*

		int used[n_events];

		for (i = 0; i < n_events; i++)

			used[i] = 0;



		for (i = 0; i < n_events; i++)

			if (events[i][0] > bd)

				bd = events[i][0];



		max_profit(events, used, n_events, bd, 0, 0);



		printf("%d\n", mp);

		*/

	}

	return 0;

}