//  ↘ ⬇ ⬇ ⬇ ⬇ ⬇ ↙
//  ➡ @roadfromroi ⬅
//  ↗ ⬆ ⬆ ⬆ ⬆ ⬆ ↖
#include <iostream>
#include "vector"
#include "algorithm"
#include "numeric"
#include "climits"
#include "iomanip"
#include "bitset"
#include "cmath"
#include "map"
#include "deque"
#include "array"
#include "set"
#include "scales.h"
//#include "graderlib.cpp"
#define all(x) x.begin(), x.end()
using namespace std;

vector<vector<int>> nbr;
int op1(int a, int b, int c, vector<int> &m) {
    if (m[a] > m[b]) {
        if (m[a] > m[c])
            return 0;
        return 2;
    } else {
        if (m[b] > m[c])
            return 1;
        return 2;
    }
}
int op2(int a, int b, int c, vector<int> &m) {
    if (m[a] < m[b]) {
        if (m[a] < m[c])
            return 0;
        return 2;
    } else {
        if (m[b] < m[c])
            return 1;
        return 2;
    }
}
int op3(int a, int b, int c, vector<int> &m) {
    if (m[a] > m[b]) {
        if (m[a] < m[c])
            return 0;
        if (m[b] > m[c])
            return 1;
        return 2;
    } else {
        if (m[a] > m[c])
            return 0;
        if (m[b] < m[c])
            return 1;
        return 2;
    }
}
int op4(int A, int B, int C, int D, vector<int> &_ind) {
    int allLess = 1;
    if (_ind[A] > _ind[D] || _ind[B] > _ind[D] || _ind[C] > _ind[D])
        allLess = 0;

    if (allLess == 1) {
        if (_ind[A] < _ind[B] && _ind[A] < _ind[C])
            return 0;

        if (_ind[B] < _ind[A] && _ind[B] < _ind[C])
            return 1;

        return 2;
    }

    if (_ind[A] > _ind[D]) {
        if ((_ind[A] < _ind[B] || _ind[B] < _ind[D]) && (_ind[A] < _ind[C] || _ind[C] < _ind[D]))
            return 0;
    }

    if (_ind[B] > _ind[D]) {
        if ((_ind[B] < _ind[A] || _ind[A] < _ind[D]) && (_ind[B] < _ind[C] || _ind[C] < _ind[D]))
            return 1;
    }

    return 2;
}
int calcvec(array<int, 5> a, vector<int> &opka) {
    if (a[0] == 1)
        return op1(a[1], a[2], a[3], opka);
    if (a[0] == 2)
        return op2(a[1], a[2], a[3], opka);
    if (a[0] == 3)
        return op3(a[1], a[2], a[3], opka);
    if (a[0] == 4)
        return op4(a[1], a[2], a[3], a[4], opka);
    exit(1);
}
int calcvec2(array<int, 10> a, vector<int> &opka) {
    array<int, 5> alft, argt;
    for (int i = 0; i < 5; ++i) {
        alft[i] = a[i];
        argt[i] = a[i + 5];
    }
    return calcvec(alft, opka) * 3 + calcvec(argt, opka);
}
int calcvec3(array<int, 15> a, vector<int> &opka) {
    array<int, 5> alft, argt, argtrgt;
    for (int i = 0; i < 5; ++i) {
        alft[i] = a[i];
        argt[i] = a[i + 5];
        argtrgt[i] = a[i + 10];
    }
    return calcvec(alft, opka) * 9 + calcvec(argt, opka) * 3 + calcvec(argtrgt, opka);
}
int calcop(array<int, 5> a, vector<vector<int>> &opka) {
    vector<int> res(3);
    for (auto i : opka)
        res[calcvec(a, i)]++;
    int rs = 0;
    for (auto i : res)
        rs = max(rs, i);
    return rs;
}
int calcop2(array<int, 10> a, vector<vector<int>> &opka) {
    vector<int> res(9);
    for (auto i : opka)
        res[calcvec2(a, i)]++;
    int rs = 0;
    for (auto i : res)
        rs = max(rs, i);
    return rs;
}
int calcop3(array<int, 15> a, vector<vector<int>> &opka) {
    vector<int> res(27);
    for (auto i : opka)
        res[calcvec3(a, i)]++;
    int rs = 0;
    for (auto i : res)
        rs = max(rs, i);
    return rs;
}
vector<array<int, 5>> allops;
vector<array<int, 10>> allops2;
vector<array<int, 15>> allops3;
void calcallops() {
    for (int a = 0; a < 4; ++a) {
        for (int b = a+1; b < 5; ++b) {
            for (int c = b+1; c < 6; ++c) {
                allops.push_back({1, a, b, c});
                allops.push_back({2, a, b, c});
                allops.push_back({3, a, b, c});
                for (int d = 0; d < 6; ++d) {
                    if (a != d and b != d and c != d) {
                        allops.push_back({4, a, b, c, d});
                    }
                }
            }
        }
    }/*
    for (auto i : allops) {
        for (auto j : allops) {
            if (i == j)
                break;
            for (auto qk : allops) {
                if (j == qk)
                    break;
                array<int, 15> c;
                for (int k = 0; k < 5; ++k) {
                    c[k] = i[k];
                    c[k + 5] = j[k];
                    c[k + 10] = qk[k];
                }
                allops3.push_back(c);
            }
        }
    }*/
}
vector<vector<vector<int>>> calcres(array<int, 5> a, vector<vector<int>> &opka) {
    vector<vector<vector<int>>> oba(3);
    for (auto i : opka)
        oba[calcvec(a, i)].push_back(i);
    return oba;
}
int delka(vector<vector<int>> &opka) {
    if (opka.size() <= 1)
        return 0;
    int mxc = opka.size();
    array<int, 5> opres;
    //cout << allops3.size() << endl;
    for (auto opop : allops) {
        int vl = calcop(opop, opka);
        //cout << vl << endl;
        if (vl < mxc) {
            mxc = vl;
            //  cout << vl << endl;
            opres = opop;
        }
    }
    //cout << opka.size() << "->" << mxc << endl;
    vector<vector<vector<int>>> oba = calcres(opres, opka);
    int rsrs = 0;
    for (auto i : oba)
        rsrs = max(rsrs, delka(i));
    return rsrs + 1;
}
int delka1(vector<vector<int>> &opka) {
    if (opka.size() <= 1)
        return 0;
    int mxc = opka.size();
    int mnt = (opka.size() + 2) / 3;
    array<int, 5> opres;
    //cout << allops3.size() << endl;
    int res = 100;
    for (auto opop : allops) {
        vector<vector<vector<int>>> oba = calcres(opop, opka);
        int rsrs = 0;
        for (auto i : oba)
            rsrs = max(rsrs, delka(i));
        res = min(res, rsrs);
        if (rsrs == 5) {
          cout << opop[0] << ' ' << opop[1] << ' ' << opop[2] << ' ' << opop[3] << ' ' << opop[4] << endl;
        }
        //cout << rsrs << endl;
    }
    //cout << opka.size() << "->" << mxc << endl;
    return res + 1;
}
int delka2(vector<vector<int>> &opka) {
    if (opka.size() <= 1)
        return 0;
    int mxc = opka.size();
    int mnt = (opka.size() + 2) / 3;
    array<int, 5> opres;
    //cout << allops3.size() << endl;
    int res = 100;
    for (auto opop : allops) {
        vector<vector<vector<int>>> oba = calcres(opop, opka);
        int rsrs = 0;
        for (auto i : oba)
            rsrs = max(rsrs, delka1(i));
        res = min(res, rsrs);
        // cout << res << endl;
    }
    //cout << opka.size() << "->" << mxc << endl;
    return res + 1;
}
array<int, 5> bstop = {3, 3, 4, 5, 0};
int myrealask(array<int, 5> a) {
    if (a[0] == 1)
        return getHeaviest(a[1]+1, a[2]+1, a[3]+1);
    if (a[0] == 2)
        return getLightest(a[1]+1, a[2]+1, a[3] + 1);
    if (a[0] == 3)
        return getMedian(a[1] + 1, a[2] + 1, a[3] + 1);
    if (a[0] == 4)
        return getNextLightest(a[1] + 1, a[2] + 1, a[3] + 1, a[4] + 1);
    exit(3);
}
int realask(array<int, 5> a) {
    //cout << a[0] << ' ' << a[1]+1 << ' ' << a[2]+1 << ' ' << a[3]+1 << ' ' << a[4]+1<< endl;
    int vl = myrealask(a);
    //cout << vl << endl;
    if (vl-1 == a[1])
        return 0;
    if (vl-1 == a[2])
        return 1;
    if (vl-1 == a[3])
        return 2;
    exit(2);
}
void realguess(vector<vector<int>> &opka) {
    //cout << "OPS"<< opka.size() << endl;
    //for (auto i : opka) {
    //    if (i == vector<int>{0, 4, 5, 2, 3, 1})
    //        cout << "DA" << endl;
    //}
    if (opka.size() == 1) {
        int a[6];
        for (int i = 0; i < 6; ++i) {
            a[opka[0][i]] = i + 1;
        }
        answer(a);
        return;
    }
    int mxc = opka.size();
    array<int, 5> opres;
    //cout << allops3.size() << endl;
    for (auto opop : allops) {
        int vl = calcop(opop, opka);
        //cout << vl << endl;
        if (vl < mxc) {
            mxc = vl;
            //  cout << vl << endl;
            opres = opop;
        }
    }
    //cout << opka.size() << "->" << mxc << endl;
    vector<vector<vector<int>>> oba = calcres(opres, opka);
    int vl = realask(opres);
    //cout << vl << endl;
    realguess(oba[vl]);
}
void init(int T) {
    //cout << T << endl;
    calcallops();
}
void orderCoins() {
    vector<vector<int>> perm;
    vector<int> a = {0, 1, 2, 3, 4, 5};
    do {
        perm.push_back(a);
    } while (next_permutation(all(a)));
    //cout << perm.size() << endl;
    vector<vector<vector<int>>> pepa = calcres(bstop, perm);
    //for (auto i : pepa) {
    //    cout << delka(i) << endl;
    //}
    realguess(pepa[realask(bstop)]);
}
void solve() {
    vector<vector<int>> perm;
    calcallops();
    vector<int> a = {0, 1, 2, 3, 4, 5};
    do {
        perm.push_back(a);
    } while (next_permutation(all(a)));
    //cout << perm.size() << endl;
    vector<vector<vector<int>>> pepa = calcres(bstop, perm);
    for (auto i : pepa) {
        cout << delka(i) << endl;
    }
    //cout << delka1(perm) << endl;
}
/*
int main() {
    solve();
    exit(0);
    int T, i;

    T = _getNumberOfTests();
    init(T);

    for (i = 1; i <= T; i++) {
        _initNewTest();
        orderCoins();
    }

    return 0;
}
*/