#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, s, t) for (int i = (int)(s); i < (int)(t); ++i)
#define revrep(i, t, s) for (int i = (int)(t)-1; i >= (int)(s); --i)
#define all(x) begin(x), end(x)
template <typename T>
bool chmax(T& a, const T& b) {
    return a < b ? (a = b, 1) : 0;
}
template <typename T>
bool chmin(T& a, const T& b) {
    return a > b ? (a = b, 1) : 0;
}

using P = pair<ll, int>;

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    for (int i = 0; i < (int)v.size(); ++i) {
        os << v[i];
        if (i < (int)v.size() - 1) os << " ";
    }
    return os;
}
template <typename T, typename U, typename V>
ostream& operator<<(ostream& os, const tuple<T, U, V>& p) {
    auto [x, y, z] = p;
    os << "(" << x << ", " << y << ", " << z << ")";
    return os;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);

    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<tuple<ll, ll, int>> neg, zero, pos;
        vector<ll> as(n), bs(n), cs(n);
        rep(i, 0, n) {
            int a, b, c;
            cin >> a >> b >> c;
            if (a < b) {
                neg.push_back({b - a, c, i});
            } else if (a == b) {
                zero.push_back({0, c, i});
            } else {
                pos.push_back({a - b, c, i});
            }
            as[i] = a, bs[i] = b, cs[i] = c;
        }

        auto calc = [&](auto& val, ll X, ll offset) -> vector<int> {
            vector<tuple<ll, ll, int>> items;
            for (auto [x, c, i] : val) {
                items.push_back({X / c - bs[i] - offset, x, i});
            }
            sort(all(items));
            ll deadline = 1e18;
            priority_queue<P, vector<P>> pq;
            vector<int> idx;
            rep(_, 0, val.size()) {
                if (!items.empty() && get<0>(items.back()) < deadline) {
                    deadline = get<0>(items.back());
                }
                while (!items.empty() && deadline <= get<0>(items.back())) {
                    auto [_, x, i] = items.back();
                    items.pop_back();
                    pq.push({x, i});
                }
                if (pq.empty()) {
                    deadline = get<0>(items.back());
                    while (!items.empty() && deadline <= get<0>(items.back())) {
                        auto [_, x, i] = items.back();
                        items.pop_back();
                        pq.push({x, i});
                    }
                }
                auto [x, i] = pq.top();
                pq.pop();
                idx.push_back(i);
                deadline -= x;
                if (deadline < 0) return {};
            }
            return idx;
        };

        auto binsearch = [&](auto& val, ll offset) {
            ll lb = 0, ub = 1e18;
            while (ub - lb > 1) {
                ll X = (lb + ub) / 2;
                auto res = calc(val, X, offset);
                if (res.empty())
                    lb = X;
                else
                    ub = X;
            }
            return calc(val, ub, offset);
        };

        ll s = 0;
        for (auto [x, c, i] : neg) s += as[i];
        for (auto [x, c, i] : zero) s += as[i];
        for (auto [x, c, i] : pos) s += bs[i];

        auto negidx = binsearch(neg, s);
        auto posidx = binsearch(pos, s);
        reverse(all(posidx));

        vector<int> ans;
        for (int i : negidx) ans.push_back(i);
        for (auto [_x, _c, i] : zero) ans.push_back(i);
        for (int i : posidx) ans.push_back(i);
        rep(i, 0, n) cout << ans[i] + 1 << (i < n - 1 ? " " : "\n");
    }
}