#include "scales.h"

#include <bits/stdc++.h>

void init(int T) {
    /* ... */
}

constexpr int N = 6;

int ask_cum(std::array<int, 4> args) {
    for (int i = 0; i < 3; i++) {
        args[i]++;
    }
    if (args[3] >= 0) {
        return getNextLightest(args[0], args[1], args[2], args[3] + 1) - 1;
    } else if (args[3] == -1) {
        return getLightest(args[0], args[1], args[2]) - 1;
    } else if (args[3] == -2) {
        return getMedian(args[0], args[1], args[2]) - 1;
    } else if (args[3] == -3) {
        return getHeaviest(args[0], args[1], args[2]) - 1;
    }
    assert(false);
}

int perform_cum(const std::array<int, 6>& data, std::array<int, 4> args) {
    auto cmp = [&](int a, int b) {
        return data[a] < data[b];
    };
    std::sort(args.begin(), args.begin() + 3, cmp);
    if (args[3] >= 0) {
        int it = std::lower_bound(args.begin(), args.begin() + 3, args[3], cmp) - args.begin();
        if (it == 3) {
            return args[0];
        }
        return args[it];
    } else {
        if (args[3] == -1) {
            return args[0];
        } else if (args[3] == -2) {
            return args[1];
        } else if (args[3] == -3) {
            return args[2];
        }
        assert(false);
    }
}

std::array<int, 4> get(std::vector<std::array<int, 6>>& all, std::vector<std::array<int, 4>> all_op, int ops_left) {
    assert(all.size() > 1);
    if (ops_left == 0) {
        return {-1, -1, -1, -1};
    }
    {
        int fuck = 1;
        for (int i = 0; i < ops_left; i++) {
            fuck *= 3;
        }
        if (fuck < all.size()) {
            return {-1, -1, -1, -1};
        }
    }

    std::vector<double> score(all_op.size());
    for (int i = 0; i < all_op.size(); i++) {
        std::array<int, 6> res;
        res.fill(0);
        const auto& op = all_op[i];
        for (const auto& vc : all) {
            res[perform_cum(vc, op)]++;
        }

        double& sc = score[i];
        for (int i : res) {
            if (i > 0) {
                // sc = std::max<int>(sc, i);
                sc += i * log(i);
            }
        }
        if (std::count(res.begin(), res.end(), 0) == 5) {
            sc = 1e9;
            all_op[i] = {-1, -1, -1, -1};
        }
    }
    score.erase(std::remove(score.begin(), score.end(), 1e9), score.end());
    all_op.erase(std::remove(all_op.begin(), all_op.end(), std::array<int, 4>{-1, -1, -1, -1}), all_op.end());

    std::vector<int> fuck(all_op.size());
    std::iota(fuck.begin(), fuck.end(), 0);

    std::sort(fuck.begin(), fuck.end(), [&](int a, int b) { return score[a] < score[b]; });
    for (int i : fuck) {
        std::array<std::vector<std::array<int, 6>>, 6> prt;
        for (const auto& vc : all) {
            prt[perform_cum(vc, all_op[i])].push_back(vc);
        }
        bool suc = true;
        for (int i = 0; i < 6; i++) {
            if (prt[i].size() > 1) {
                if (get(prt[i], all_op, ops_left - 1).front() == -1) {
                    suc = false;
                    break;
                }
            }
        }
        if (suc) {
            return all_op[i];
        }
    }
    return {-1, -1, -1, -1};
}

void orderCoins() {
    std::vector<std::array<int, 6>> all;
    {
        std::array<int, 6> p;
        std::iota(p.begin(), p.end(), 0);
        do {
            all.push_back(p);
        } while (std::next_permutation(p.begin(), p.end()));
    }

    std::vector<std::array<int, 4>> all_op;
    for (int i = 0; i < 6; i++) {
        for (int j = i + 1; j < 6; j++) {
            for (int t = j + 1; t < 6; t++) {
                all_op.push_back({i, j, t, -1});
                all_op.push_back({i, j, t, -2});
                all_op.push_back({i, j, t, -3});
                for (int c = 0; c < 6; c++) {
                    if (i != c && j != c && t != c) {
                        all_op.push_back({i, j, t, c});
                    }
                }
            }
        }
    }
    // std::cerr << all.size() << std::endl;

    int ops_left = 6;
    int iter = 0;
    while (all.size() > 1) {
        // std::cerr << min.first << "\n";
        // const auto& op = all_op[min.second];
        std::array<int, 4> op;
        if (iter <= 1) {
            if (iter == 0) {
                op = {0, 1, 2, -1};
            } else {
                op = {3, 4, 5, -2};
            }
            // op = {0, 1, 2, -2};
            // op = {0, 1, 2, 3};
            ops_left--;
        } else {
            op = get(all, all_op, ops_left--);
            assert(op.front() != -1);
            // for (int i = 0; i < 4; i++) {
            //     std::cerr << op[i] << " \n"[i == 3];
            // }
        }

        int cum = ask_cum(op);
        for (auto& vc : all) {
            if (perform_cum(vc, op) != cum) {
                vc.fill(0);
            }
        }

        all.erase(std::remove(all.begin(), all.end(), std::array<int, 6>{0, 0, 0, 0, 0, 0}), all.end());
        iter++;
    }
    assert(all.size() == 1);

    auto ans = all.front();
    for (int& i : ans) {
        i++;
    }
    std::array<int, 6> crap;
    for (int i = 0; i < 6; i++) {
        crap[ans[i] - 1] = i + 1;
    }

    std::cerr << "SUC\n";
    std::cerr.flush();

    answer(crap.data());
}