// cf bits/extc++.h nonsense
#ifdef ONLINE_JUDGE
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
#endif
#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using u64 = uint64_t;
using ll = long long;
using ld = long double;

template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

inline void init_io() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
}

template <typename T>
vector<T> iota(int n, const T& init) {
    vector<T> arr(n);

    iota(begin(arr), end(arr), init);

    return arr;
}

template <typename T>
vector<vector<T>> transposed(const vector<vector<T>>& arr) {
    int n = sz(arr), m = sz(arr[0]);

    vector ans(m, vector<T>(n));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            ans[j][i] = arr[i][j];
        }
    }

    return ans;
}

template <typename T>
bool on(const T& mask, int bit) {
    return (mask >> bit) & 1;
}

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
    return out << "(" << p.first << ", " << p.second << ")";
}

template <typename A, typename T>
int lbs(const A& arr, const T& x) {
    return int(lower_bound(begin(arr), end(arr), x) - begin(arr));
}

inline vector<bool>::reference& operator&=(vector<bool>::reference&& a, bool b) {
    return a = a & b;
}

template <typename T>
T reversed(T arr) {
    reverse(begin(arr), end(arr));
    return arr;
}

/// You may use:

// The number of students
int N, n, T;

// The probability any given student is positive
double P, p;

// This function performs a test on a subset of samples.
// Its argument is a vector of Booleans of length N,
// where the i-th element is true if the i-th sample should be added to the mix.
// It returns true if (and only if) at least one of the samples in the mix is
// positive.
bool test_students(std::vector<bool> mask) {
    assert(mask.size() == (size_t)N);

    std::string mask_str(N, ' ');
    for (int i = 0; i < N; i++)
        mask_str[i] = mask[i] ? '1' : '0';

    printf("Q %s\n", mask_str.c_str());
    fflush(stdout);

    char answer;
    scanf(" %c", &answer);
    return answer == 'P';
}

bool query_inter(int ql, int len) {
    vector<bool> cq(n);

    fill_n(begin(cq) + ql, len, true);

    return test_students(cq);
}

vector<float> dp2, pcomp1;
vector<vector<float>> dp1, pcomp2;

// prob of m things having a 1 in them
float prob1(int m) {
    return pcomp1[m];
}

// probability of a 1 being in first m things if tot things have a 1 in them
float prob2(int m, int tot) {
    return pcomp2[m][tot];
    // return prob1(m) / prob1(tot);
};

void pcomp() {
    if (T == 1) {
        return;
    }
    pcomp1 = vector(n + 1, float(0));
    for (int m = 0; m <= n; m++) {
        pcomp1[m] = 1 - pow(1 - p, m);
    }

    pcomp2 = vector(n + 1, vector(n + 1, float(0)));
    for (int m = 0; m <= n; m++) {
        for (int tot = m; tot <= n; tot++) {
            pcomp2[m][tot] = prob1(m) / prob1(tot);
        }
    }

    dp2 = vector(n + 1, float(1e9));
    dp1 = vector(n + 1, vector(n + 1, float(1e9)));
    dp2[0] = 0;

    for (int tot = 1; tot <= n; tot++) {
        for (int extra = tot - 1; extra >= 0; extra--) {
            int cur = tot - extra;

            if (cur == 1) {
                assert(dp2[extra] < 1e8);
                dp1[extra][cur] = dp2[extra];
            }

            for (int i = 1; i < cur; i++) {
                float cp = prob2(i, cur);

                assert(dp1[extra + cur - i][i] < 1e8);
                assert(dp1[extra][cur - i] < 1e8);
                dp1[extra][cur] =
                    min(dp1[extra][cur], 1 + cp * (dp1[extra + cur - i][i]) +
                                             (1 - cp) * dp1[extra][cur - i]);
            }
        }

        for (int i = 1; i <= tot; i++) {
            float cp = prob1(i);

            assert(dp1[tot - i][i] < 1e8);
            assert(dp2[tot - i] < 1e8);
            dp2[tot] = min(dp2[tot],
                           1 + cp * dp1[tot - i][i] + (1 - cp) * dp2[tot - i]);
        }
    }
    dbg(dp2);
    dbg(dp1);
}

/// You should implement:

// This function will be called once for each test instance.
// It should use test_students to determine which samples are positive.
// It must return a vector of Booleans of length N,
// where the i-th element is true if and only if the i-th sample is positive.
vector<bool> find_positive() {
    vector<bool> ans(n);
    if (T == 1) {
        for (int i = 0; i < n; i++) {
            ans[i] = query_inter(i, 1);
        }
        return ans;
    }
    assert(false);

    int ind = 0;
    while (ind < n) {
        int tot = n - ind;

        pair opt {float(1e9), -1};

        for (int i = 1; i <= tot; i++) {
            float cp = prob1(i);

            assert(dp1[tot - i][i] < 1e8);
            assert(dp2[tot - i] < 1e8);
            opt = min(opt,
                      {1 + cp * dp1[tot - i][i] + (1 - cp) * dp2[tot - i], i});
        }

        if (!query_inter(ind, opt.second)) {
            ind += opt.second;
            continue;
        }

        int cur = opt.second, extra = tot - cur;
        while (cur > 1) {
            opt = {float(1e9), -1};

            for (int i = 1; i < cur; i++) {
                float cp = prob2(i, cur);

                assert(dp1[extra + cur - i][i] < 1e8);
                assert(dp1[extra][cur - i] < 1e8);
                opt = min(opt, {1 + cp * (dp1[extra + cur - i][i]) +
                                    (1 - cp) * dp1[extra][cur - i],
                                i});
            }

            int i = opt.second;
            if (query_inter(ind, i)) {
                extra += cur - i;
                cur = i;
            } else {
                ind += i;
                cur -= i;
            }
        }

        ans[ind] = true;
        ind++;
    }

    return ans;
}

int main() {
    scanf("%d %lf %d", &N, &P, &T);
    n = N;
    p = P;
    pcomp();

    // You may perform any extra initialization here.

    for (int i = 0; i < T; i++) {
        std::vector<bool> answer = find_positive();
        assert(answer.size() == (size_t)N);

        std::string answer_str(N, ' ');
        for (int j = 0; j < N; j++)
            answer_str[j] = answer[j] ? '1' : '0';

        printf("A %s\n", answer_str.c_str());
        fflush(stdout);

        char verdict;
        scanf(" %c", &verdict);
        if (verdict == 'W')
            exit(0);
    }

    return 0;
}