/*
    題意：從上到下為1到N層，每一層三個(gè)值Wi,Li,Pi，分別表示已有水量，該層容量，手動(dòng)放水價(jià)格
    如果某一層的水超過(guò)Li，就會(huì)自動(dòng)將全部水往下泄；也可以手動(dòng)放水
    問(wèn)要使第N層水泄，至少的代價(jià)

    一個(gè)必要條件：
    如果第p層被手動(dòng)放水，在其下的水都要被放走（自動(dòng)或手動(dòng)），即水不可能斷流！

    可以枚舉最高放水點(diǎn)p，然后向下計(jì)算代價(jià)即可O(n^2)  n<=15000 TLE
    代價(jià)的計(jì)算：
                                  i
    如果層i需要手動(dòng)放水，必須 ∑W[j]<=L[i]
                                  j=p
    
    剛才是打算枚舉p，然后每次都計(jì)算代價(jià)，可不可以不用每次都重新計(jì)算呢？
    對(duì)于最高點(diǎn)為p的，其下層需要放水的集合 S[p]={i | ∑W[j]<=L[i]}
    而對(duì)于p+1的，以p為最高點(diǎn)時(shí)層i如果需要手動(dòng)放水，則以p+1為最高點(diǎn)時(shí)也必然要手動(dòng)放水
    因?yàn)椤芖[j]減小了          即 S[p]∈S[p+1] , i>=p+1         ★★★

             i
    設(shè)A[i] = ∑W[j]-L[i] ,對(duì)A[i]排序，這時(shí)的A[i]其實(shí)就是p=1時(shí)的情況了
             j=1
    推到p=2,只需看A[i]-W[1]是否<=0  是的話(huà)表示需要手動(dòng)放水
    推到p=3,只需看A[i]-W[1]-W[2]
    

    用pos記錄目前需要手動(dòng)放水的 A[pos]
    如果在枚舉p時(shí)，pos前的需要手動(dòng)放水，則枚舉p+1時(shí)，pos前的也需要手動(dòng)放水
    所以pos這個(gè)指針不用回退的

    法一：可以按照A[]  sort一下，然后從p=1開(kāi)始推.
           Sort完后保證了前面的算過(guò)的對(duì)于后面的也是有效的
    法二：由S[p]∈S[p+1] , i>=p+1  
           可以用一個(gè)最大堆來(lái)做，對(duì)于最高點(diǎn)p，堆存的是p及之下的需要手動(dòng)放水的層
           i從N往前枚舉 
           維護(hù)：i+1->i時(shí)，加入i，并將堆里不需要手動(dòng)放水的去掉，得到最終的代價(jià)了
    
    啟示：有單調(diào)性的，排序后就不用重復(fù)計(jì)算了！！
           跟ZJOI 2010 Base 一樣的思想，排序后算，指針不用回退！
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

const int MAXN = 15010;
const int INF = 1000000000;

struct Level
{
    int W,L,P;
    int key;
    bool operator<(const Level &B)const
    {
        return key<B.key;
    }
};

Level levels[MAXN];

bool vi[MAXN];
int id[MAXN];

bool cmp(const int &a,const int b)
{
    return levels[a].key<levels[b].key;
}

int main()
{
    //freopen("in","r",stdin);

    int N;
    while(~scanf("%d",&N))
    {
        int totalW = 0,nowCost = 0;
        //fill(vi+1,vi+1+N,false);
        for(int i=1;i<=N;i++)
        {
            id[i]=i;
            scanf("%d%d%d",&levels[i].W,&levels[i].L,&levels[i].P);
            totalW += levels[i].W;
            levels[i].key = totalW-levels[i].L;
            //if(levels[i].key<=0)//
            //{
            //    vi[i]=true;
            //    nowCost+=levels[i].P;
            //}
        }

        //sort(id+1,id+1+N,cmp);

        //int bestP = 1,bestCost = nowCost;
        //int subW=0,pos=1;
        //for(int p=2;p<=N;p++)
        //{
        //    subW+=levels[p-1].W;
        //    if(vi[p-1])//如果p之前的被算進(jìn)nowCost來(lái)的話(huà)要減去
        //        nowCost-=levels[p-1].P;  

        //    while(pos<=N&&levels[id[pos]].key-subW<=0)
        //    {
        //        if(!vi[id[pos]]&&id[pos]>=p)//p作為最高頂點(diǎn)時(shí)，層i需要手動(dòng)放水，則加上代價(jià)
        //        {
        //            vi[id[pos]]=true;
        //            nowCost+=levels[id[pos]].P;
        //        }
        //        pos++;
        //    }
        //    if(nowCost<bestCost)
        //    {
        //        bestCost = nowCost;
        //        bestP = p;
        //    }
        //}



        /******************************************************/        
        int bestCost = INF,bestP;
        priority_queue<Level> PQ;
        for(int i=N;i;i--)
        {
            totalW-=levels[i].W;            
            PQ.push(levels[i]);
            nowCost+=levels[i].P;
            while(!PQ.empty()&&PQ.top().key-totalW>0)//>0  不用放水的去掉
            {
                nowCost-=PQ.top().P;
                PQ.pop();
            }
            if(nowCost<bestCost)
            {
                bestCost = nowCost;
                bestP = i;
            }
        }
        /******************************************************/

        int addW = 0;
        for(int i=bestP;i<=N;i++)
        {
            addW+=levels[i].W;
            if(addW<=levels[i].L)
                printf("%d\n",i);
        }
    }
    return 0;
}