#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int l, w, h;
} Block;

int cmp(const void *a, const void *b) {
    Block *x = (Block*)a;
    Block *y = (Block*)b;
    // Sắp xếp giảm dần theo diện tích đáy
    long long area1 = (long long)x->l * x->w;
    long long area2 = (long long)y->l * y->w;
    if (area1 != area2) return (area1 > area2) ? -1 : 1;
    // Nếu diện tích bằng, ưu tiên chiều cao lớn hơn (không bắt buộc nhưng tốt cho DP)
    return y->h - x->h;
}

int main() {
    int n;
    while (scanf("%d", &n) == 1 && n != 0) {
        Block blocks[600]; // 200 loai * 3 huong
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            int x, y, z;
            scanf("%d %d %d", &x, &y, &z);
            // 3 huong xoay (chon 1 chieu lam cao)
            // Truong hop 1: chieu cao la z
            int l = x, w = y;
            if (l < w) { int t = l; l = w; w = t; }
            blocks[cnt++] = (Block){l, w, z};
            // Truong hop 2: chieu cao la y
            l = x; w = z;
            if (l < w) { int t = l; l = w; w = t; }
            blocks[cnt++] = (Block){l, w, y};
            // Truong hop 3: chieu cao la x
            l = y; w = z;
            if (l < w) { int t = l; l = w; w = t; }
            blocks[cnt++] = (Block){l, w, x};
        }
        // Sap xep giam dan theo kich thuoc day (l*w)
        qsort(blocks, cnt, sizeof(Block), cmp);
        // Quy hoach dong
        int dp[600];
        int max_h = 0;
        for (int i = 0; i < cnt; i++) {
            dp[i] = blocks[i].h;
            for (int j = 0; j < i; j++) {
                // Kiem tra dieu kien an toan: day phai lon hon day duoi
                if (blocks[j].l > blocks[i].l && blocks[j].w > blocks[i].w) {
                    if (dp[j] + blocks[i].h > dp[i]) {
                        dp[i] = dp[j] + blocks[i].h;
                    }
                }
            }
            if (dp[i] > max_h) max_h = dp[i];
        }
        printf("%d\n", max_h);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int l, w, h;
} Block;

int cmp(const void *a, const void *b) {
    Block *x = (Block*)a;
    Block *y = (Block*)b;
    long long area1 = (long long)x->l * x->w;
    long long area2 = (long long)y->l * y->w;
    return (area1 > area2) ? -1 : 1;
}

int main() {
    int n;
    while (scanf("%d", &n) == 1 && n != 0) {
        Block blocks[600];
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            int x, y, z;
            scanf("%d %d %d", &x, &y, &z);
            // Sinh 3 hướng xoay, chuẩn hóa để length >= width
            int dims[3][3] = {{x, y, z}, {y, z, x}, {z, x, y}};
            for (int k = 0; k < 3; k++) {
                int l = dims[k][0];
                int w = dims[k][1];
                int h = dims[k][2];
                if (l < w) { int t = l; l = w; w = t; }
                blocks[cnt++] = (Block){l, w, h};
            }
        }
        qsort(blocks, cnt, sizeof(Block), cmp);
        int dp[600];
        int ans = 0;
        for (int i = 0; i < cnt; i++) {
            dp[i] = blocks[i].h;
            for (int j = 0; j < i; j++) {
                // Do đã sort giảm dần diện tích, chỉ cần so sánh l hoặc w là đủ
                // Tuy nhiên điều kiện an toàn vẫn là cả 2 chiều đều nhỏ hơn
                if (blocks[j].l > blocks[i].l && blocks[j].w > blocks[i].w) {
                    if (dp[j] + blocks[i].h > dp[i])
                        dp[i] = dp[j] + blocks[i].h;
                }
            }
            if (dp[i] > ans) ans = dp[i];
        }
        printf("%d\n", ans);
    }
    return 0;
}

// Lưu ý: Đây là một hướng tiếp cận THAM LAM thường bị nhầm lẫn.
// Nó KHÔNG giải quyết đúng bài toán này vì điều kiện 'cả hai chiều' 
// dẫn đến các cấu trúc phức tạp không tối ưu theo局部最优.
// Ví dụ: Khối (5,5,10) và (4,6,10). 
// Tham lam có thể chọn (5,5) rồi không còn chỗ cho (4,6) hoăc ngược lại.

// Code minh họa cho thấy tại sao Greedy không hoạt động:
// 1. Sắp xếp giảm dần chiều cao? -> Sai.
// 2. Chọn khối diện tích lớn nhất? -> Sai.
// 3. Chọn khối cao nhất? -> Sai.

// Chỉ có Quy hoạch động là chính xác trong bài toán này.