/*
         --┬--  |     |  --┬--                |       |
           |    |\    |    |                  |       |
           |    | \   |    |     ----->       |       |
           |    |  \  |    |                  |       |
           |    |   \ |    |                  |       |
         --┴--  |    \|    |                  └----   └----

*/

// #define pragma

#ifdef pragma
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC diagnostic ignored "-Wunused-result"
#endif // pragma

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define all(x) begin(x), end(x)
#define pb push_back
#define x first
#define y second
#define int long long
#define zero(x) memset(x, 0, sizeof(x))

using namespace std;
using namespace __gnu_pbds;


typedef vector<int> vi;
typedef vector<bool> vb;
typedef pair<int, int> pii;
typedef long double ld;
typedef vector<vi> matrix;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

const int INF = 1e9 + 7;
const ld EPS = 1e-9;
const ld PI = atan2(0, -1);

void seriy() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cout << fixed << setprecision(10);
    #if 1
        freopen("input", "r", stdin);
        freopen("output", "w", stdout);
    #endif
}

struct p {
    int l, r, c;
};

struct pt {
    int x, left, c, num;
};

bool cmp(pt a, pt b) {
    return a.x < b.x || a.x == b.x && a.c > b.c;
}

signed main() {
    seriy();
    int n;
    cin >> n;
    vector<p> seg(n);
    vector<pt> a;
    for(int i = 0; i < n; i++) {
        cin >> seg[i].l >> seg[i].r >> seg[i].c;
        a.pb({seg[i].l, -1, 0, i + 1});
        a.pb({seg[i].l + seg[i].r, seg[i].l, seg[i].c, i + 1});
    }
    if(n == 1) {
        return cout << seg[0].c << "\n1\n1", 0;
    }
    sort(all(a), cmp);
    vi dp(2 * n);
    map<int, int> mp;
    vector<pii> p(2 * n);
    p[0] = {-1, a[0].num};
    // cerr << " 0 ";
    for(int i = 1; i < 2 * n; i++) {
        if(a[i].left == -1) {
            dp[i] = dp[i - 1];
            mp[a[i].x] = i;
            if(a[i - 1].left == -1) {
                p[i] = p[i - 1];
            }
            else {
                p[i] = {i - 1, a[i].num};
            }
        }
        else {
            dp[i] = dp[mp[a[i].left]] + a[i].c;
            p[i] = {mp[a[i].left], a[i].num};
            if(dp[i - 1] > dp[i]) {
                dp[i] = dp[i - 1];
                p[i] = p[i - 1];
            }
        }
        // cerr << dp[i] << " ";
    }
    // cerr << '\n';
    int cur = 0;
    for(int i = 0; i < 2 * n; i++) {
        // cerr << p[i] << " ";
        if(dp[i] > dp[cur]) {
            cur = i;
        }
    }
    cout << dp[cur] << '\n';
    vi ans;
    // cerr << '\n';
    while(cur >= 0) {
        // cerr << cur << " ";
        if(a[cur].left != -1) ans.pb(p[cur].y);
        cur = p[cur].x;
    }
    reverse(all(ans));
    cout << ans.size() << '\n';
    for(int i = 0; i < ans.size(); i++) {
        cout << ans[i] << " ";
    }
    return 0;
}