#include <bits/stdc++.h>

using i64 = long long;

constexpr int N = 1 << 12;

struct Info {
    i64 sum = 0;
    i64 max = 0;
    i64 pre = 0;
    i64 suf = 0;
};

Info operator+(const Info &a, const Info &b) {
    Info c;
    c.sum = a.sum + b.sum;
    c.max = std::max({a.max, b.max, a.suf + b.pre});
    c.pre = std::max(a.pre, a.sum + b.pre);
    c.suf = std::max(a.suf + b.sum, b.suf);
    return c;
}

Info t[N];

void pull(int p) {
    t[p] = t[2 * p] + t[2 * p + 1];
}

void modify(int p, int l, int r, int x, i64 v) {
    if (r - l == 1) {
        i64 mv = std::max(0LL, v);
        t[p] = {v, mv, mv, mv};
        return;
    }
    int m = (l + r) / 2;

    if (x < m) {
        modify(2 * p, l, m, x, v);
    } else {
        modify(2 * p + 1, m, r, x, v);
    }

    pull(p);
}

void solve() {
    int n;
    std::cin >> n;

    std::vector<int> x(n), y(n), w(n);
    for (int i = 0; i < n; i++) {
        std::cin >> x[i] >> y[i] >> w[i];
    }

    auto vx = x, vy = y;
    std::sort(vx.begin(), vx.end());
    std::sort(vy.begin(), vy.end());
    vx.erase(std::unique(vx.begin(), vx.end()), vx.end());
    vy.erase(std::unique(vy.begin(), vy.end()), vy.end());
    int nx = vx.size(), ny = vy.size();

    std::vector<std::vector<std::pair<int, int>>> a(nx);
    for (int i = 0; i < n; i++) {
        x[i] = std::lower_bound(vx.begin(), vx.end(), x[i]) - vx.begin();
        y[i] = std::lower_bound(vy.begin(), vy.end(), y[i]) - vy.begin();
        a[x[i]].emplace_back(y[i], w[i]);
    }
    i64 ans = 0;
    for (int i = 0; i < nx; i++) {
        std::vector<i64> val(ny);
        for (int j = 0; j < ny; j++) {
            modify(1, 0, ny, j, 0);
        }
        for (int j = i; j < nx; j++) {
            for (auto [y, w] : a[j]) {
                val[y] += w;
                modify(1, 0, ny, y, val[y]);
            }
            ans = std::max(ans, t[1].max);
        }
    }
    std::cout << ans << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}