#pragma GCC optimize("O3,unroll-loops")
#include <bits/stdc++.h>

int N, K;
char str[1000];
std::vector<unsigned long long> dp[50];
long long st[50][50][50 * 50];

int main() {
    for (int i = 0; i < 50; ++i)
        for (int j = 0; j < 50; ++j)
            for (int k = 0; k < 50 * 50; ++k) st[i][j][k] = -1;
    scanf("%d%d", &N, &K);
    scanf(" %s", str);
    {
        long long cnt = 0, a = 0, b = 0, c = 0;
        for (int i = 0; i < N; ++i) {
            cnt += str[i] == '?';
            a += str[i] == 'N';
            if (str[i] == 'A') {
                b += a;
            }
            if (str[i] == 'C') {
                c += b;
            }
        }
        long long rem = cnt;
        while ((rem / 3) * ((rem + 1) / 3) * ((rem + 2) / 3) + c >= K) --rem;
        long long diff = cnt - rem - 2;
        if (diff > 0)
            for (int i = 0; i < N; ++i) {
                if (str[i] == '?') {
                    str[i] = 'B';
                    --diff;
                    if (diff == 0) {
                        break;
                    }
                }
            }
    }
    // printf("::%lld\n", rem);
    dp[0].push_back(0);
    for (int i = 0; i < N; ++i) {
        dp[i + 1].reserve(dp[i].size() * 4);
        std::sort(dp[i].begin(), dp[i].end());
        // printf("%d: %d\n", i, dp[i].size());
        for (long long j = 0; j < std::min((int) dp[i].size(), 1000000); ++j) {
            if (j > 0 && dp[i][j] >> 32 == dp[i][j - 1] >> 32) {
                continue;
            }
            long long a = dp[i][j] >> 58 & 0x3F;
            long long b = dp[i][j] >> 45 & 0x1FFF;
            long long c = dp[i][j] >> 32 & 0x1FFF;
            // long long jj = dp[i][j] >> 2 & 0x3FFFFFFF;
            if (c == K || c + b == K || c + b + b <= K || c + b + a <= K) {
                long long rem = N - i;
                long long best = st[rem][a][b];
                if (best < 0) {
                    // best = b * rem + a * (rem / 2) * ((rem + 1) / 2) + (rem /
                    // 3) * ((rem + 1) / 3) * ((rem + 2) / 3);
                    for (long long z = 0; z <= rem; ++z) {
                        long long tot = rem - z;
                        long long axy = 0;
                        if (tot <= a) {
                            axy = a * tot;
                        } else {
                            axy = ((a + tot) / 2) * ((a + tot + 1) / 2);
                        }
                        best = std::max(best, (axy + b) * z);
                    }
                    st[rem][a][b] = best;
                }
                if (c + best >= K) {
                    if (str[i] == 'N') {
                        dp[i + 1].push_back(a + 1 << 58 | b << 45 | c << 32 |
                                            j << 2 | 0);
                    } else if (str[i] == 'A') {
                        dp[i + 1].push_back(a << 58 | b + a << 45 | c << 32 |
                                            j << 2 | 0);
                    } else if (str[i] == 'C') {
                        dp[i + 1].push_back(a << 58 | b << 45 | c + b << 32 |
                                            j << 2 | 0);
                    } else if (str[i] == '?') {
                        if (a + 1 + b + c <= K)
                            dp[i + 1].push_back(a + 1 << 58 | b << 45 |
                                                c << 32 | j << 2 | 1);
                        if (a > 0 && b + a + c <= K)
                            dp[i + 1].push_back(a << 58 | b + a << 45 |
                                                c << 32 | j << 2 | 2);
                        if (b > 0 && c + b <= K)
                            dp[i + 1].push_back(a << 58 | b << 45 |
                                                c + b << 32 | j << 2 | 3);
                        dp[i + 1].push_back(a << 58 | b << 45 | c << 32 |
                                            j << 2 | 0);
                    } else {
                        dp[i + 1].push_back(a << 58 | b << 45 | c << 32 |
                                            j << 2 | 0);
                    }
                }
            }
        }
    }
    for (long long f = 0; f < dp[N].size(); ++f) {
        long long c = dp[N][f] >> 32 & 0x1FFF;
        if (c == K) {
            std::string ans;
            // printf("%d %lld %d\n", f, c, K);
            for (int i = N; i > 0; --i) {
                ans.push_back(dp[i][f] & 3
                                  ? "?NAC"[dp[i][f] & 3]
                                  : (str[i - 1] == '?' ? 'B' : str[i - 1]));
                f = dp[i][f] >> 2 & 0x3FFFFFF;
                // printf("%d %d %d %lld %d\n", i, (int)dp[i].size(), f, c, K);
            }
            std::reverse(ans.begin(), ans.end());
            printf("%s\n", ans.c_str());
            return 0;
        }
    }
    puts("-1");
}