#include <bits/stdc++.h>

using namespace std;

#define FOR(a, b, c) for(int a = (b); a < (c); a++)
#define SZ(a) (int)((a).size())
#define SIZE(a) (int)((a).size())
#define ALL(a) (a).begin(), (a).end()
using ll = long long;
#define LL long long
#define PB push_back

const int MAX = 2e5 + 7;
const int INF = 1e9 + 7;
int gowno[MAX][3][2];
set <int> fromleft, fromright;
int arr[MAX];
map <int, pair <int, int> > pos;

using tre=tuple<int,int,int>;

set <tre> ans;

int miniL[MAX];
int miniP[MAX];
int maxiBelowL[MAX];
int maxiBelowP[MAX];

int main() {
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int n;
    cin >> n;

    vector <pair <int, int> > tosort;

    FOR(i, 0, n)
    {
        cin >> arr[i];
        tosort.PB({arr[i], i});

        if(pos.count(arr[i]))
            pos[arr[i]].second = i;
        else
            pos[arr[i]] = {i, i};
        
        if(fromleft.size() && *fromleft.begin() < arr[i])
            gowno[i][0][0] = 1;

        if(fromleft.count(arr[i]))
            gowno[i][1][0] = 1;

        if(fromleft.size() && *(--fromleft.end()) > arr[i])
            gowno[i][2][0] = 1;
        fromleft.insert(arr[i]);
    }

    for(int i = n - 1; i >= 0; --i)
    {
        if(fromright.size() && *fromright.begin() < arr[i])
            gowno[i][0][1] = 1;

        if(fromright.count(arr[i]))
            gowno[i][1][1] = 1;

        if(fromright.size() && *(--fromright.end()) > arr[i])
            gowno[i][2][1] = 1;
        fromright.insert(arr[i]);
    }

    FOR(i, 0, n)
    {
        if(gowno[i][1][0] && gowno[i][0][1])
            ans.insert({1, 1, 2});
        if(gowno[i][1][0] && gowno[i][2][1])
            ans.insert({2, 2, 1});
        if(gowno[i][1][0] && gowno[i][1][1])
            ans.insert({1, 1, 1});
        if(gowno[i][0][0] && gowno[i][2][1])
            ans.insert({1, 2, 3});
        if(gowno[i][2][0] && gowno[i][0][1])
            ans.insert({3, 2, 1});
        if(gowno[i][0][0] && gowno[i][1][1])
            ans.insert({1, 2, 2});
        if(gowno[i][2][0] && gowno[i][1][1])
            ans.insert({2, 1, 1});
    }

    sort(ALL(tosort));

    set <int> ids;
    int prev = -1;
    FOR(i, 0, n)
    {
        int val = tosort[i].first;
        if(val != prev)
        {
            auto z = pos[val];

            auto t = ids.lower_bound(z.first);
            if(t != ids.end() && *t < z.second)
                ans.insert({2, 1, 2});
        }

        ids.insert(tosort[i].second);
        prev = tosort[i].first;
    }
    ids.clear();
    prev = -1;
    for(int i = n - 1; i >= 0; --i)
    {
        int val = tosort[i].first;
        if(val != prev)
        {
            auto z = pos[val];

            auto t = ids.lower_bound(z.first);
            if(t != ids.end() && *t < z.second)
                ans.insert({1, 2, 1});
        }

        ids.insert(tosort[i].second);
        prev = tosort[i].first;
    }



    int mini = INF;
    FOR(i, 0, n)
    {
        miniL[i] = mini;
        mini = min(mini, arr[i]);
    }

    mini = INF;
    for(int i = n - 1; i >= 0; --i)
    {
        miniP[i] = mini;
        mini = min(mini, arr[i]);
    }

    set<int> secik;
    secik.insert(-INF);
    FOR(i, 0, n)
    {
        auto it = secik.insert(arr[i]).first;
        maxiBelowL[i] = *(--it);
    }
    secik.clear();
    secik.insert(-INF);

    for(int i = n - 1; i >= 0; --i)    
    {
        auto it = secik.insert(arr[i]).first;
        maxiBelowP[i] = *(--it);
    }

    FOR(i, 1, n - 1)
    {
        if(miniL[i] < maxiBelowP[i])
            ans.insert({1,3,2});
        if(miniP[i] < maxiBelowL[i])
            ans.insert({2,3,1});
    }


    mini = -INF;
    FOR(i, 0, n)
    {
        miniL[i] = mini;
        mini = max(mini, arr[i]);
    }

    mini = -INF;
    for(int i = n - 1; i >= 0; --i)
    {
        miniP[i] = mini;
        mini = max(mini, arr[i]);
    }

    secik.clear();
    secik.insert(INF);
    FOR(i, 0, n)
    {
        auto it = secik.insert(arr[i]).first;
        maxiBelowL[i] = *(++it);
    }
    secik.clear();
    secik.insert(INF);

    for(int i = n - 1; i >= 0; --i)    
    {
        auto it = secik.insert(arr[i]).first;
        maxiBelowP[i] = *(++it);
    }

    FOR(i, 1, n - 1)
    {
        if(miniL[i] > maxiBelowP[i])
            ans.insert({3,1,2});
        if(miniP[i] > maxiBelowL[i])
            ans.insert({2,1,3});
    }

    for(auto& z : ans)
    {
        cout << get<0>(z) << get<1>(z) << get<2>(z) << "\n";
    }
}