#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <array>
#define int long long
#define pii std::pair<int, int>
struct piv {
    int x;
    int prev;
    std::vector<int> v;
};
class cmp {
    bool operator ()(const piv& a, const piv& b) {
        return a.x < b.x;
    }
};
void dfs(int node, int prev, std::vector<bool> vis, const std::vector<std::vector<int>>& g,
    int& ans, const std::vector<int>& c, std::vector<int> v) {
    if (vis[node]) {
        int sum = 0;
        for (int& i : v) {
            sum += c[i];
        }
        ans = std::max(ans, sum);
        return;
    }
    for (int i : v) {
        if (std::find(g[node].begin(), g[node].end(), i) == g[node].end()) {
            return;
        }
    }
    v.push_back(node);
    vis[node] = true;
    for (int i : g[node]) {
        if (i != prev) {
            dfs(i, node, vis, g, ans, c, v);
        }
    }
}
// class dsu {
// public:
//     dsu(int n);
//     int find(int x);
//     bool unite(int x, int y);
//     bool connected(int x, int y);
// private:
//     std::vector<int> par;
//     std::vector<int> sz;
// };
// dsu::dsu(int n) {
//     par = std::vector<int>(n);
//     sz = std::vector<int>(n, 1);
//     for (int i = 0; i < n; ++i) {
//         par[i] = i;
//     }
// };
// int dsu::find(int x) {
//     return (x == par[x] ? x : (par[x] = find(par[x])));
// };
// bool dsu::connected(int x, int y) {
//     return find(x) == find(y);
// };
// bool dsu::unite(int x, int y) {
//     int parx = find(x);
//     int pary = find(y);
//     if (parx == pary) {
//         return false;
//     }
//     if (sz[parx] < sz[pary]) {
//         std::swap(parx, pary);
//     }
//     par[pary] = parx;
//     sz[parx] += sz[pary];
//     return true;
// };
void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n), b(n), c(n);
    // std::unordered_map<int, int> mp;
    // dsu ds(n);
    // for (int i = 0; i < n; ++i) {
    //     std::cin >> a[i] >> b[i] >> c[i];
    //     mp[i] = c[i];   
    // }
    auto is_connected = [&](const int& x, const int& y) -> bool {
        std::unordered_map<int, int> cnt;
        ++cnt[a[x]];
        ++cnt[a[y]];
        ++cnt[b[x]];
        ++cnt[b[y]];
        return ((int)cnt.size() < 4);  
    };
    // for (int i = 0; i < n; ++i) {
    //     for (int j = 0; j < n; ++j) {
    //         if (is_connected(i, j)) {
    //             ds.unite(i, j);
    //         }
    //     }
    // }
    std::vector<std::vector<int>> g(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> a[i] >> b[i] >> c[i];
    }
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (is_connected(i, j)) {
                g[i].push_back(j);
                g[j].push_back(i);
                if (i != j) ans = std::max(ans, c[i] + c[j]);
            }
        }
    }
    // std::priority_queue<piv, std::vector<piv>, std::greater<piv>> pq;
    // pq.push({0, 0, {}});
    // while (!pq.empty()) {
    //     auto p = pq.top();
    //     pq.pop();

    // }
    for (int i = 0; i < n; ++i) {
        std::vector<int> v = {};
        std::vector<bool> vis(n, false);
        dfs(i, -1, vis, g, ans, c, v);
    }
    std::cout << ans << '\n';
}
signed main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
    int t;
    std::cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}