#pragma GCC optimize("O3,unroll-loops")

#include <chrono>
#include <iostream>
#include <sys/wait.h>
#include <vector>
#include <array>
#include <string>
#include <algorithm>
#include <iomanip>
#include <map>
#include <deque>
#include <set>
#include <cassert>
#include <unordered_map>
#include <random>

using namespace std;
#define ll long long

struct Part {
    ll sum = 0;
    vector<int> els;
};

bool cmp(const Part &a, const Part &b) {
    return a.sum < b.sum;
}

Part operator-(const Part &a, const Part &b) {
    Part ans;
    ans.sum = a.sum - b.sum;
    ans.els = a.els;
    for (int i: b.els) {
        ans.els.push_back(-i);
    }
    return ans;
}

mt19937_64 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());

ll randint(ll l, ll r) {
    ll flex = l + rnd() % (r - l + 1);
    return flex;
}

ll INF = 1e12;

bool LOC = false;

struct Part2 {
    ll sum;
    vector<pair<Part, int>> els;
};

bool cmp2(const Part2 &a, const Part2 &b) {
    return a.sum < b.sum;
}

Part2 operator-(const Part2 &a, const Part2 &b) {
    Part2 ans;
    ans.sum = a.sum - b.sum;
    ans.els = a.els;
    for (auto i: b.els) {
        ans.els.emplace_back(i.first, -i.second);
    }
    return ans;
}

void solve() {
    int n;
    cin >> n;
    vector<ll> a(n);
    
    if (!LOC) {
        for (int i = 0; i < n; ++i) cin >> a[i];
    } else {
        for (int i = 0; i < n; ++i) a[i] = randint(1, INF);
    }
    if (n == 6) {
        cout << "ABC.BA";
        return;
    }
    while (true) {
        vector <int> used(n);
        for (int i = 0; i < 100; ++i) {
            int x = randint(0, n - 1);
            used[x] = 1;
        }

        vector<Part> good;
        vector<Part> parts;
        for (int i = 0; i < n; ++i) {
            if (used[i]) continue;
            parts.push_back({a[i], {i + 1}});
        }
        while (parts.size() > 1) {
            sort(parts.begin(), parts.end(), cmp);
            vector<Part> nparts;

            for (int i = 1; i < parts.size(); i += 2) {
                auto npart = parts[i] - parts[i - 1];
                if (npart.sum == 0) {
                    good.push_back(npart);
                } else {
                    nparts.push_back(npart);
                }
            }
            parts = nparts;
        }

        vector<Part2> flex;
        for (auto i: good) {
            ll my_sum = 0;
            for (int j: i.els) {
                if (j > 0) my_sum += a[j - 1];
            }
            flex.push_back({my_sum, {{i, 1}}});
        }

        Part2 res;
        res.sum = -1;
        // cout << flex.size() << endl;
        ll mini = INF;

        while (flex.size() > 1) {
            sort(flex.begin(), flex.end(), cmp2);
            mini = min(mini, flex[0].sum);
            vector<Part2> nflex;

            for (int i = 1; i < flex.size(); i += 2) {
                auto npart = flex[i] - flex[i - 1];
                if (npart.sum != 0) {
                    nflex.push_back(npart);
                } else {
                    res = npart;
                    break;
                }
            }

            if (res.sum == 0) break;
            flex = nflex;
        }

        // cout << res.sum << " " << mini << endl;
        if (res.sum == 0) {
            string answer(n, '.');
            for (auto i : res.els) {
                if (i.second == 1) {
                    for (int j : i.first.els) {
                        if (j > 0) answer[j - 1] = 'A';
                        else answer[-j - 1] = 'B';
                    }
                } else {
                    for (int j : i.first.els) {
                        if (j > 0) answer[j - 1] = 'C';
                    }
                }
            }

            ll suma = 0;
            ll sumb = 0;
            ll sumc = 0;

            for (int i = 0; i < n; ++i) {
                if (answer[i] == 'A') suma += a[i];
                else if (answer[i] == 'B') sumb += a[i];
                else if (answer[i] == 'C') sumc += a[i];
            }

            assert(suma == sumb);
            assert(suma == sumc);
            cout << answer;
            return;
        }
    }
}

signed main() {
    if (1) {
        ios_base::sync_with_stdio(false);
        cin.tie(nullptr);
    }
    int t = 1;
//    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

/*
5 6
1 2
1 3
3 4
3 5
? 2 5
+ 1 4 1
? 2 5
+ 4 5 2
? 4 5
? 1 1
 */