#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<map>
using namespace std;
 
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(n) rep(i,n)
#define all(n) n.begin(),n.end()
 
const int TO = 4, BO = 5, F = 0, B = 1, R = 2, L = 3; 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const int OFS = 100;
struct dice {int d[6]; };

void printd(dice di)
{
    cout << di.d[TO] << endl;
    cout << di.d[F] << " " << di.d[R] << " " << di.d[B] << " " << di.d[L] << endl;
    cout << di.d[BO] << endl;
}
int RIGHT[7][7] = {
    {0,0,0,0,0,0,0,},
    {0,0,3,5,2,4,0,},
    {0,4,0,1,6,0,3,},
    {0,2,6,0,0,1,5,},
    {0,5,1,0,0,6,2,},
    {0,3,0,6,1,0,4,},
    {0,0,4,2,5,3,0,}
};
void roll(dice* di, int vec)
{
    int t;
    if(vec == F)
    {
        t = di->d[F];
        di->d[F] = di->d[TO];
        di->d[TO] = di->d[B];
        di->d[B] = di->d[BO];
        di->d[BO] = t;
    }
    if(vec == R)
    {
        t = di->d[R];
        di->d[R] = di->d[TO];
        di->d[TO] = di->d[L];
        di->d[L] = di->d[BO];
        di->d[BO] = t;
    }
    if(vec == L)
    {
        t = di->d[L];
        di->d[L] = di->d[TO];
        di->d[TO] = di->d[R];
        di->d[R] = di->d[BO];
        di->d[BO] = t;
    }
    if(vec == B)
    {
        t = di->d[B];
        di->d[B] = di->d[TO];
        di->d[TO] = di->d[F];
        di->d[F] = di->d[BO];
        di->d[BO] = t;
    }
};
const int W = 210;
typedef pair<int, int> pp;
 
int main()
{
    int n;
    while(cin >> n && n)
    {
        int tops[W][W] = {}, h[W][W] = {};
        REP(n)
        {
            int t, f;
            cin >> t >> f;
            dice tmp;
            tmp.d[TO] = t; tmp.d[F] = f; tmp.d[R] = RIGHT[t][f];
            tmp.d[L] = 7 - tmp.d[R]; tmp.d[B] = 7 - tmp.d[F];
            tmp.d[BO] = 7 - tmp.d[TO];
            int x = OFS; int y = OFS; int nowh = h[x][y]; int rollf = 1;
            //cout << "initialized  " << endl;
            while(rollf)
            {
                rollf = 0;
                vector<pp> r;
                r.push_back(pp( -tmp.d[F], F));r.push_back(pp(-tmp.d[R], R));
                r.push_back(pp( -tmp.d[B], B));r.push_back(pp(-tmp.d[L], L));
                sort(all(r));
                rep(j,4) if(nowh > h[x + dx[r[j].second]][y + dy[r[j].second]] &&
                        -r[j].first >= 4)
                {
                    roll(&tmp, r[j].second);
                    rollf = 1;
                    x += dx[r[j].second]; y += dy[r[j].second]; nowh = h[x][y];
                    break;
                }
            }
            h[x][y]++; tops[x][y] = tmp.d[TO];
        }
        //cout << "rolled " << endl;
        int ans[7] = {};
        rep(i, W)rep(j,W) ans[tops[i][j]]++;
        cout<<ans[1]<<" "<<ans[2]<<" "<<ans[3]<<" "
            <<ans[4]<<" "<<ans[5]<<" "<<ans[6]<<endl;
    }
    return 0;
}