#pragma GCC optimize("Ofast")

#include "bits/stdc++.h"


#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
//#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

// [l, r)
template<typename T, typename F>
T FindFirstTrue(T l, T r, const F &predicat) {
    --l;
    while (r - l > 1) {
        T mid = l + (r - l) / 2;
        if (predicat(mid)) {
            r = mid;
        } else {
            l = mid;
        }
    }
    return r;
}


template<typename T, typename F>
T FindLastFalse(T l, T r, const F &predicat) {
    return FindFirstTrue(l, r, predicat) - 1;
}

const int INFi = 2e9;
const ll INF = 2e18;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const ll MX = 1e12;
std::uniform_int_distribution<ll> distrib(1, MX);

vl Gen(int n) {
    vl a(n);
    rep(i, n) {
        a[i] = distrib(rng);
    }
    return a;
}


const int ITS = 1e6;
const int S = 4;

//ll target;

//struct Generator {
//    vl v;
//    map<ll, ar<int, S>> can;
//
//    vector<int> us;
//    vi tt;
//    vector<bool> bad;
//    int T;
//
//    Generator(vl x) {
//        v = x;
//
//        int sz = v.size();
//        us = vector<int>(sz);
//        tt = vector<int>(sz);
//        iota(all(tt), 0);
//        bad.resize(sz, false);
//
//        T = 0;
//
////        vector<pair<ll, ar<int, S>>> kek;
////        rep(_, ITS) {
////            T++;
////            int ptr = 0;
////            ll res = 0;
////            ar<int, S> cur;
////            rep(t, S) cur[t] = -1;
////            while (ptr < S) {
////                int i = tt[rng() % (int) tt.size()];
////                if (us[i] == T) continue;
////                us[i] = T;
////                cur[ptr++] = i;
////                res += v[i];
////            }
////            kek.emplace_back(res, cur);
////        }
////
////        can = map<ll, ar<int, S>>(all(kek));
//    }
//
//    ll step(Generator &gen2) {
//        T++;
//        int ptr = 0;
//        ll res = 0;
//        ar<int, S> cur;
//        rep(t, S) cur[t] = -1;
//        while (ptr < S) {
//            int i = tt[rng() % (int) tt.size()];
//            if (us[i] == T) continue;
//            us[i] = T;
//            cur[ptr++] = i;
//            res += v[i];
//
//            ll val = target - res;
//            if (val <= 0) break;
//            can[res] = cur;
//
//            if (ptr > 1) if (gen2.can.count(val)) return res;
//        }
//        return -1;
//    }
//
//    void Del(ar<int, S> &was) {
//        for (auto &i: was) {
//            if (i == -1) break;
//            assert(!bad[i]);
//            bad[i] = true;
//        }
//
//        {
//            int j = 0;
//            rep(i, tt.size()) {
//                if (bad[tt[i]]) continue;
//                swap(tt[i], tt[j++]);
//            }
//            tt.resize(j);
//        }
//
//        vl del;
//        for (auto &[sum, ve]: can) {
//            bool ok = true;
//            for (auto &j: ve) {
//                if (j == -1) break;
//                if (bad[j]) {
//                    ok = false;
//                    break;
//                }
//            }
//            if (!ok) del.push_back(sum);
//        }
//        for (auto &x: del) can.erase(x);
//    }
//
//    ar<int, S> Do(ll s) {
//        auto was = can[s];
//        Del(was);
//        return was;
//    }
//};

vector<ar<int, S>> result;

struct MySet {
    vector<ar<int, S>> sets;
    vector<vector<bool>> can;

    MySet() {}

    bool Add(ar<int, S> x) {
        int sz = sets.size();
        vector<bool> cur(sz);
        rep(j, sz) {
            bool ok = true;
            rep(t, 3) {
                rep(f, 3) {
                    if (sets[j][t] == x[f]) {
                        ok = false;
                        break;
                    }
                }
                if (!ok) break;
            }
            cur[j] = ok;
        }
        can.push_back(cur);
        sets.push_back(x);

        rep(j, sz) {
            if (!can[sz][j]) continue;
            rep(e, j) {
                if (can[sz][e] && can[j][e]) {
                    result = {sets[e], sets[j], sets[sz]};
                    return true;
                }
            }
        }
        return false;
    }
};

void solve() {
    int n; cin >> n;
    vl a(n);
    rep(i, n) cin >> a[i];

    if (n == 6) {
        cout << "ABC.BA\n";
        return;
    }
//    auto a = Gen(n);

//    map<ll, MySet> mp;
//
//    vi us(n);
//    int T = 0;
//    while (true) {
//        T++;
//        ar<int, S> x;
//        ll res = 0;
//        int ptr = 0;
//        while (ptr < S) {
//            int i = rng() % (int) n;
//            if (us[i] == T) continue;
//            us[i] = T;
//            x[ptr++] = i;
//            res += a[i];
//        }
//        if (mp[res].Add(x)) {
//            break;
//        }
//
//        if (T % (n * 10) == 0) {
//            cerr << T << endl;
//        }
//    }
//
//    cerr << "OK" << endl;
//    cerr

    ll target = 1ll * 2 * (1 + MX);

    string res(n, '.');

    MySet top;

    auto Find = [&] () {
        n = a.size();
        int M = n / 2;
        vector<pair<ll, int>> Av;
        rep(i, M) Av.emplace_back(a[i], i);
        sort(all(Av));

        auto Find1 = [&] (ar<int, S> &cur, ll s1) {
            int ptr = Av.size() - 1;
            for(int i = 0; i < Av.size(); ++i) {
                while (ptr >= 0 && Av[i].first + Av[ptr].first > s1) ptr--;
                assert(ptr >= 0);
                if (Av[i].first + Av[ptr].first == s1) {
                    cur[0] = Av[i].second;
                    cur[1] = Av[ptr].second;
                    return;
                }
            }
            assert(0);
        };

        int cnt = 1ll * M * (M - 1) / 2;
        vl A(cnt);
        int ptr = 0;
        for(int i = 0; i < M; ++i) {
            for(int j = 0; j < i; ++j) {
                A[ptr++] = a[i] + a[j];
            }
        }
        assert(ptr == cnt);

        int L = n - M;
        int cnt2 = 1ll * L * (L - 1) / 2;
        ptr = 0;
        vl B(cnt2);
        for(int i = M; i < n; ++i) {
            for(int j = M; j < i; ++j) {
                B[ptr++] = a[i] + a[j];
            }
        }
        assert(ptr == cnt2);

        sort(all(A));
        sort(all(B));


        vector<pair<ll, int>> Bv;
        for(int i = M; i < n; ++i) Bv.emplace_back(a[i], i);
        sort(all(Bv));

        auto Find2 = [&] (ar<int, S> &cur, ll s1) {
            int ptr = Bv.size() - 1;
            for(int i = 0; i < Bv.size(); ++i) {
                while (ptr >= 0 && Bv[i].first + Bv[ptr].first > s1) ptr--;
                assert(ptr >= 0);
                if (Bv[i].first + Bv[ptr].first == s1) {
                    cur[2] = Bv[i].second;
                    cur[3] = Bv[ptr].second;
                    return;
                }
            }
            assert(0);
        };

        ptr = (int)B.size() - 1;
        for(auto &s1 : A) {
            while (ptr >= 0 && s1 + B[ptr] > target) ptr--;
            if (ptr < 0) break;
            if (s1 + B[ptr] == target) {
                ar<int, S> cur;
                Find1(cur, s1);
                Find2(cur, B[ptr]);
                if (top.Add(cur)) {
                    return;
                }
            }
        }
        assert(0);
    };

    Find();

    string T = "ABC";
    rep(j, 3) {
        ll sum = 0;
        for(auto &i : result[j]) {
            assert(res[i] == '.');
            res[i] = T[j];
            sum += a[i];
        }
        assert(sum == target);
//        cerr << sum << '\n';
    }

    cout << res << '\n';


//    for (auto ch: T) {
//        ll
//    }
//    Generator g1(vl(a.begin(), a.begin() + M));
//    Generator g2(vl(a.begin() + M, a.begin() + n));
//
//    string res(n, '.');
//    string T = "ABC";
//
//    for (auto ch: T) {
//        cerr << ch << endl;
//        ll S1 = -1;
////        {
////            for(auto &[s1, _] : g1.can) {
////                if (g2.can.count(target - s1)) {
////                    S1 = s1;
////                    break;
////                }
////            }
////        }
//        if (S1 == -1) {
//            for (int it = 0;; ++it) {
//                {
//                    ll s1 = g1.step(g2);
//                    if (s1 != -1) {
//                        cerr << "OK " << it << '\n';
//                        S1 = s1;
//                        break;
//                    }
//                }
//                {
//                    ll s2 = g2.step(g1);
//                    if (s2 != -1) {
//                        S1 = target - s2;
//                        break;
//                    }
//                }
//            }
//        }
//
//        auto i1 = g1.Do(S1);
//        auto i2 = g2.Do(target - S1);
//
//        ll s = 0;
//        for (auto &i: i1) {
//            if (i == -1) continue;
//            assert(res[i] == '.');
//            res[i] = ch;
//            s += a[i];
//        }
//
//        for (auto &i: i2) {
//            if (i == -1) continue;
//            i += M;
//            assert(res[i] == '.');
//            res[i] = ch;
//            s += a[i];
//        }
//
//        assert(s == target);
//    }
//
//    cout << res << '\n';
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(12) << fixed;
    int t = 1;


//    cin >> t;
    rep(i, t) {
        solve();
    }

    return 0;
}