#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<set>
#include<map>
#include<stack>
#include<complex>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<deque>


using namespace std;
// using namespace __gnu_cxx;

typedef long long ll;
typedef double db;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;

#define INF (1<<30)
#define PB push_back
#define FI first
#define SE second
#define REP(i,n) for(int (i)=0;(i)<(n);++(i))
#define FUP(i,a,b) for(int (i)=(a);(i)<=(b);++(i))
#define FDN(i,a,b) for(int (i)=(a);(i)>=(b);--(i))

const int MAXN = 5001;

int position[5];
int whenEven[5][MAXN];
int cycle[5];
vector<pair<int, int> > primes[5];

int n, N;

int fun(int pos) {
    if(pos < n*2) {
        return pos/2 * 5 + pos%2;
    } else if(pos < n*4) {
        pos -= n*2;
        return pos/2 * 5 + 2 + pos%2;
    } else {
        pos -= n*4;
        return pos * 5 + 4;
    }
}

ll modPow(ll a, ll b, ll m) {
    if(b == 0) return 1;
    ll x = modPow((a*a) % m, b/2, m);
    if(b%2) x = (x*a) % m;
    return x;
}

ll pow1(ll a, ll b) {
    if(b == 0) {
        return 1;
    }
    if(b % 2){
        return pow(a*a, b/2)*a;
    } else {
        return pow(a*a, b/2);
    }
}

int make() {
    scanf("%d", &n); N = n*5;
    if(!n) return 0;

    REP(i, N) {
        int a; scanf("%d", &a); --a;
        if(a < 5) position[a] = i;
    }
    
    if(n == 1) {
        printf("Player 1 wins game number 1.\n");
        return 1;
    }

    REP(i, 5) REP(j, N) {
        whenEven[i][j] = -1;
    }

    REP(i, 5) {
        int pos = position[i];
        int time = 0;
        while(whenEven[i][pos] == -1) {
            whenEven[i][pos] = time;
            ++time;
            pos = fun(pos);
        }
        cycle[i] = time;
    }
/*
    REP(i, 5){
        REP(j, N) {
            printf("%d ", whenEven[i][j]);
        }
        printf("\n");
    }
*/
    REP(i, 5) {
        int c = cycle[i];
        for(int p = 2; c > 1; ++p) {
            int k = 0;
            while((c%p) == 0) {
                ++k;
                c /= p;
            }
            if(k > 0) {
                primes[i].PB(make_pair(p, k));
            }
        }
    }
/*
    REP(i, 5) {
        printf("%d\n", cycle[i]);
        REP(j, primes[i].size()) {
            printf("%d %d\n",primes[i][j].first, primes[i][j].second);
        }
    }
*/
    int winner = -1;
    ll winnerTime = 9223372036854775807ll;

    vector<int> perm;
    REP(i, 5) perm.PB(i);
    ll powerM;

    REP(i, n) {
        do {
            int ok = 1;
            REP(j, 5) {
                if(whenEven[j][5*i+perm[j]] == -1){
                    ok = 0;
                    break;
                }
            }
            if(!ok) continue;

            vector<pair<pair<int, int>, int> > all;
            vector<pair<pair<int, int>, int> > needed;
            vector<ll> powers;

            REP(j, 5) {
                REP(l, primes[j].size()) {
                    all.PB(make_pair(primes[j][l], whenEven[j][5*i+perm[j]] % pow1(primes[j][l].first, primes[j][l].second)));
                }
            }

            sort(all.begin(), all.end());

            REP(j, all.size()) {
                if(j < all.size() - 1) {
                    if(all[j].first.first == all[j+1].first.first) {
                        if(all[j].second != (all[j+1].second % pow1(all[j].first.first, all[j].first.second))) {
                            ok = 0;
                            break;
                        }
                    } else {
                        needed.PB(all[j]);
                    }
                } else {
                    needed.PB(all[j]);
                }
            }
            if(!ok) continue;

            powerM = 1;
            REP(j, needed.size()) {
                powers.PB(pow1(needed[j].first.first, needed[j].first.second));
                powerM *= powers.back();
            }

            vector<ll> a, d, r;
            REP(j, needed.size()) {
                a.PB(needed[j].second);
                d.PB(1);
                REP(l, needed.size()){
                    if(l != j) {
                        d.back() = d.back() * powers[l];
                    }
                }
                r.PB(modPow(d.back(), pow1(needed[j].first.first, needed[j].first.second-1) * (needed[j].first.first - 1) - 1, powers[j]));
            }

            ll currentTime = 0;
            REP(j, needed.size()) {
                currentTime = (currentTime + ((a[j] * d[j]) % powerM) * r[j]) % powerM;
            }

            if(currentTime == 0){
                currentTime = powerM;
            }

            if(currentTime <= winnerTime) {
                winnerTime = currentTime;
                winner = i;
            }
        } while(next_permutation(perm.begin(), perm.end()));
    }

    if(winner != -1) {
        printf("Player %d wins game number %lld.\n", winner + 1, winnerTime);
    } else {
        printf("Neverending game.\n");
    }

    REP(i, 5) {
        primes[i].clear();
    }
    return 1;
}

int main(){
    while(make());
    return 0;
}