#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

long long factorial(long long n); //Factorial
long long factorial(long long n, long long x ); // Factorial with modulo
bool isPowerOfTwo (long long x); //Function to check if x is power of 2
long long binpow(long long a, long long b); // return a ^ b
long long binpow(long long a, long long b, long long m); // return (a^b) mod m
long long lcm (long long a, long long b); // least common multiple
long long gcd(long long a, long long b, long long& x, long long& y); //extended euclidean algorithm
pair<long long, long long> fib (long long n); // n-th and (n+1)-th Fibonacci numbers
//dfs
long long mostSignificantDigit(long long N );
long long numberOfDigits(long long N );







typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pair<int,int>> pi;
typedef vector<pair<long long,long long>> pll;


#define F first
#define S second
#define PB push_back
#define MP make_pair
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define REPA(i,a,b,c) for (int i = a; i <= b; i+=c)


//TRICKS

//Checking if the number is even or odd without using the % operator:
/*
if (num & 1) 
	cout << "ODD"; 
else
	cout << "EVEN"; 
*/

//emplace_back() instead of push_back()
/*
// are all of the elements positive?
all_of(first, first+n, ispositive()); 

// is there at least one positive element?
any_of(first, first+n, ispositive());

// are none of the elements positive?
none_of(first, first+n, ispositive()); 


Copy Algorithm: used to copy elements from one container to another.
// copy 5 elements from source to target
copy_n(source, sizeOfArray, target);

Initialization in Binary form
auto number = 0b011; 
cout << number;
OUTPUT: 3

*/




int n;
string s;

int zeros;
int ones;
string ans = "";


int main() {
	ios_base::sync_with_stdio(0);

    cin >> n;
    cin >> s;
    for (auto c : s) {
        if(c=='1') {
            ones++;
        }
        else {
            zeros++;
        }
    }
    //cout << "zeros - ones: " << zeros - ones << '\n';
    if(zeros-ones>=0) {
        while(zeros-ones>=2 && zeros>=5 && ones >= 3) {
            ans += 'a';
            zeros -= 5;
            ones -= 3;
        }
        while(zeros-ones==0 && zeros>=4 && ones >= 4) {
            ans += 'c';
            zeros -= 4;
            ones -= 4;
        }
        if( zeros==0 && ones==0) {
            cout << ans << '\n';
        }
        else {
            cout << "NIE" << '\n';
        }
    }
    else {
        //cout << "ones-zeros: " << ones - zeros << '\n';
       // cout << "ones: " << ones << '\n';
        //cout << "zeros: " << zeros << '\n';
        while(ones-zeros>=4 && zeros>=2 && ones>=6) {
            ans += 'o';
            zeros -= 2;
            ones -= 6;
        }
        while(ones-zeros>=2 && zeros>=3 && ones>=5) {
            ans += 'g';
            zeros -= 3;
            ones -= 5;
        }
        while(ones-zeros==0 && zeros>=4 && ones>=4) {
            ans += 'c';
            zeros -= 4;
            ones -= 4;
        }
        if(zeros==0 && ones==0) {
            cout << ans << '\n';
        }
        else {
            cout << "NIE" << '\n';
        }
    }



	return 0;
}













long long factorial(long long n) 
{ 
    if (n == 0) 
        return 1; 
    return n * factorial(n - 1); 
} 

long long factorial(long long n, long long x ) {
    ll res = 1;
    for ( ll i = 1; i <= n; i++ ) {
        res *= i;
        res %= x;
    }
    return res;
}




// return a ^ b
long long binpow(long long a, long long b) {
    long long res = 1;
    while (b > 0) {
        if (b & 1)
            res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}

// return (a^b) mod m
long long binpow(long long a, long long b, long long m) {
    a %= m;
    long long res = 1;
    while (b > 0) {
        if (b & 1)
            res = res * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return res;
}
// least common multiple
long long lcm (long long a, long long b) {
    return a / __gcd(a, b) * b;
}
//extended euclidean algorithm
long long gcd(long long a, long long b, long long& x, long long& y) {
    x = 1, y = 0;
    long long x1 = 0, y1 = 1, a1 = a, b1 = b;
    while (b1) {
        long long q = a1 / b1;
        tie(x, x1) = make_tuple(x1, x - q * x1);
        tie(y, y1) = make_tuple(y1, y - q * y1);
        tie(a1, b1) = make_tuple(b1, a1 - q * b1);
    }
    return a1;
}
// n-th and (n+1)-th Fibonacci numbers
pair<long long, long long> fib (long long n) {
    if (n == 0)
        return {0, 1};

    auto p = fib(n >> 1);
    long long c = p.first * (2 * p.second - p.first);
    long long d = p.first * p.first + p.second * p.second;
    if (n & 1)
        return {d, c + d};
    else
        return {c, d};
}

//dfs
/*
void dfs(int v ) {
    visited[v] = true;
    for (int i = 0; i < (int) G [ v ].size(); i++ ) {
    	int u = G [ v ] [ i ];
        if (!visited[u])
            dfs(u);
    }
}
*/

//bfs
/*




*/


/* Function to check if x is power of 2*/
bool isPowerOfTwo (long long x) 
{ 
  /* First x in the below expression is  
    for the case when x is 0 */
  return x && (!(x&(x-1))); 
} 

long long mostSignificantDigit(long long N ) {
	long double K = log10(N);
	K = K - floor(K);
	long long X = pow(10, K);
	return X;
}
long long numberOfDigits(long long N ) {
	N = floor(log10(N)) + 1;
	return N;
}