// Datacenter Imprisonment (D) — distributed maze scan, v2.
//
// Maze model (from provided generator source): rooms at odd (r,c) are always
// empty, even/even cells are always walls; the only unknown cells are the
// E = 2m(m-1) "door" cells between adjacent rooms, m = (N+1)/2.
//
// Plan: split the E door queries across agents as contiguous ranges of a
// Hilbert-curve enumeration (each range is a compact 2D blob). Workers scan
// their range, pack answers 6 bits per printable char, and stream chunks to
// agent 0 eagerly; when done they simply exit (an exit does not consume a
// turn, unlike `halt`). Agent 0 scans a smaller share (to pay for its receive
// turns), collects all bits, and claims as soon as (1,1) and (N,N) are
// connected in the discovered room forest (DSU early stop).
//
// While scanning, two sound inference rules answer some doors without a
// query (the empty cells form a spanning tree of the rooms):
//   cycle rule: endpoints already connected in my discovered forest -> closed
//   cut rule:   an endpoint's component has exactly one unknown incident
//               candidate edge left -> that edge must be open
// This skips ~9-12% of queries on large mazes. The scheduler discounts
// expected query turns with a conservative piecewise factor; if a range
// happens to need more queries than budgeted, agent 0 just retries `< ?`
// a few extra turns (graceful, still correct).
//
// Worker loads are staggered (worker A-1 finishes last, worker 1 first) so
// the final chunks arrive at agent 0 about one per turn and it rarely idles.
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

static const char* ALPH =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static int VAL[256];

static int N, A, ID, B;   // maze size, num agents, my id, max msg len
static ll m, E, L;        // rooms per side, candidate door edges, bits per msg

static string rd() {
    string s;
    if (!getline(cin, s)) exit(0);
    return s;
}
static void wr(const string& s) {
    cout << s << '\n';
    cout.flush();
}

struct EdgeI {
    int u, v;   // room indices (row*m+col)
    char dir;   // direction u -> v: 'R' or 'D'
    int qr, qc; // door cell to query
};

// Raw edge enumeration: for each room row r: (m-1) horizontal doors, then
// (for r < m-1) m vertical doors below the row.
static EdgeI edgeInfoRaw(ll idx) {
    ll rowBlock = 2 * m - 1;
    ll full = (m - 1) * rowBlock;
    ll r, off;
    if (idx < full) {
        r = idx / rowBlock;
        off = idx % rowBlock;
    } else {
        r = m - 1;
        off = idx - full;
    }
    if (off < m - 1) {
        int u = (int)(r * m + off);
        return {u, u + 1, 'R', (int)(2 * r + 1), (int)(2 * off + 2)};
    }
    ll c = off - (m - 1);
    int u = (int)(r * m + c);
    return {u, (int)(u + m), 'D', (int)(2 * r + 2), (int)(2 * c + 1)};
}

// ---------------- Hilbert ordering ----------------

static ll hilbertD(int x, int y, int order) {
    ll d = 0;
    for (int s = order / 2; s > 0; s /= 2) {
        int rx = (x & s) > 0, ry = (y & s) > 0;
        d += (ll)s * s * ((3 * rx) ^ ry);
        if (ry == 0) {
            if (rx == 1) {
                x = s - 1 - x;
                y = s - 1 - y;
            }
            swap(x, y);
        }
    }
    return d;
}

static vector<ll> PERM;  // position -> raw edge index, Hilbert order of door cells

static void buildPerm() {
    int order = 1;
    while (order < N + 2) order <<= 1;
    vector<pair<ll, ll>> keys(E);
    for (ll e = 0; e < E; ++e) {
        EdgeI ei = edgeInfoRaw(e);
        keys[e] = {hilbertD(ei.qr, ei.qc, order), e};
    }
    sort(keys.begin(), keys.end());
    PERM.resize(E);
    for (ll i = 0; i < E; ++i) PERM[i] = keys[i].second;
}

static inline EdgeI edgeInfo(ll idx) { return edgeInfoRaw(PERM[idx]); }

static bool probeCell(int qr, int qc) {
    char buf[48];
    snprintf(buf, sizeof buf, "? %d %d", qr, qc);
    wr(buf);
    string r = rd();
    return !r.empty() && r[0] == '1';
}

// ---------------- inference state ----------------
// Shared by workers and agent 0's own scanning phase. slot[root] counts
// candidate edges incident to the component that are still unknown to *me*
// (edges outside my range never resolve and stay counted).

struct Infer {
    vector<int> par;
    vector<ll> slot;
    Infer(int n) : par(n), slot(n, 0) {
        iota(par.begin(), par.end(), 0);
        int mm = (int)m;
        for (int r = 0; r < mm; ++r)
            for (int c = 0; c < mm; ++c)
                slot[r * mm + c] = (r > 0) + (r + 1 < mm) + (c > 0) + (c + 1 < mm);
    }
    int find(int x) {
        while (par[x] != x) x = par[x] = par[par[x]];
        return x;
    }
    void unite(int a, int b) {
        a = find(a);
        b = find(b);
        if (a == b) return;
        par[a] = b;
        slot[b] += slot[a];
    }
    // Resolve edge (u,v): returns {open, queried}.
    pair<bool, bool> resolve(const EdgeI& e) {
        int ru = find(e.u), rv = find(e.v);
        if (ru == rv) {  // cycle rule: must be closed
            slot[ru] -= 2;
            return {false, false};
        }
        if (slot[ru] == 1 || slot[rv] == 1) {  // cut rule: must be open
            slot[ru]--;
            slot[rv]--;
            unite(e.u, e.v);
            return {true, false};
        }
        bool open = probeCell(e.qr, e.qc);
        slot[ru]--;
        slot[rv]--;
        if (open) unite(e.u, e.v);
        return {open, true};
    }
};

// ---------------- schedule ----------------
// Worker i's turn count is q(p_i) + ceil(p_i/L) (queries + sends; exit is
// free). Agent 0's is q(p_0) + M + 1 (queries + receives + claim), M = total
// messages. q(p) is a conservative bound on queries needed to resolve p
// edges of a Hilbert range (calibrated by offline simulation; observed max
// ratios: ~0.905 at p~2500, ~0.93 at p~600, ~0.99 at p~100).

static const ll SLACK = 1;

static ll qNeed(ll p) {
    int pct;
    if (p < 300) pct = 100;
    else if (p < 1000) pct = 96;
    else if (p < 3000) pct = 93;
    else if (p < 20000) pct = 91;
    else pct = 89;
    return (p * pct + 99) / 100;
}

static ll sendsFor(ll p) { return p ? (p + L - 1) / L : 0; }

// max p with qNeed(p) + sendsFor(p) <= cap
static ll maxProbes(ll cap) {
    if (cap < 2) return 0;
    ll lo = 0, hi = cap * 2 + 4;
    while (lo < hi) {
        ll mid = (lo + hi + 1) / 2;
        if (qNeed(mid) + sendsFor(mid) <= cap)
            lo = mid;
        else
            hi = mid - 1;
    }
    return lo;
}

// max p with qNeed(p) <= budget
static ll maxRootProbes(ll budget) {
    if (budget <= 0) return 0;
    ll lo = 0, hi = budget * 2 + 4;
    while (lo < hi) {
        ll mid = (lo + hi + 1) / 2;
        if (qNeed(mid) <= budget)
            lo = mid;
        else
            hi = mid - 1;
    }
    return lo;
}

static bool feasible(ll T, vector<ll>& pout) {
    vector<ll> pmax(A, 0);
    for (int i = 1; i < A; ++i) {
        // worker i must send its last chunk by T-2-SLACK-(A-1-i) so agent 0
        // can read the staggered final chunks one per turn and claim by T
        ll cap = T - 2 - SLACK - (ll)(A - 1 - i);
        pmax[i] = maxProbes(cap);
    }
    ll M = 0;
    for (int iter = 0; iter < 400; ++iter) {
        ll p0 = min(E, maxRootProbes(T - 1 - SLACK - M));
        ll rem = E - p0, Mact = 0;
        vector<ll> p(A, 0);
        p[0] = p0;
        for (int i = A - 1; i >= 1 && rem > 0; --i) {
            p[i] = min(pmax[i], rem);
            rem -= p[i];
            Mact += sendsFor(p[i]);
        }
        if (rem > 0) return false;
        if (qNeed(p0) + Mact + 1 + SLACK <= T) {
            pout = p;
            return true;
        }
        if (Mact <= M) return false;
        M = Mact;
    }
    return false;
}

static vector<ll> computeSchedule() {
    ll lo = 1, hi = E + 2LL * A + 64;
    vector<ll> best;
    while (lo <= hi) {
        ll mid = lo + (hi - lo) / 2;
        vector<ll> p;
        if (feasible(mid, p)) {
            best = p;
            hi = mid - 1;
        } else {
            lo = mid + 1;
        }
    }
    if (best.empty()) {  // paranoia: agent 0 does everything alone
        best.assign(A, 0);
        best[0] = E;
    }
    return best;
}

// ---------------- worker ----------------

static void runWorker(ll S, ll cnt) {
    if (cnt == 0) return;  // exit now; costs no turns
    Infer inf((int)(m * m));
    string buf;
    int acc = 0, nb = 0;
    for (ll t = 0; t < cnt; ++t) {
        EdgeI e = edgeInfo(S + t);
        auto [open, queried] = inf.resolve(e);
        if (open) acc |= 1 << nb;
        if (++nb == 6) {
            buf.push_back(ALPH[acc]);
            acc = 0;
            nb = 0;
        }
        if (queried && (int)buf.size() >= B) {
            wr("> 0 " + buf.substr(0, B));
            buf.erase(0, B);
            rd();  // OK
        }
    }
    if (nb) buf.push_back(ALPH[acc]);
    while (!buf.empty()) {
        int take = min<int>(B, (int)buf.size());
        wr("> 0 " + buf.substr(0, take));
        buf.erase(0, take);
        rd();  // OK
    }
    // fall through to exit; merlin treats EOF like halt but without a turn
}

// ---------------- agent 0 ----------------

struct DSU {
    vector<int> p;
    DSU(int n) : p(n) { iota(p.begin(), p.end(), 0); }
    int find(int x) {
        while (p[x] != x) x = p[x] = p[p[x]];
        return x;
    }
    void uni(int a, int b) {
        a = find(a);
        b = find(b);
        if (a != b) p[a] = b;
    }
};

static vector<uint8_t> knownBit, openR, openD;
static DSU* dsu;

static bool connectedSG() { return dsu->find(0) == dsu->find((int)(m * m - 1)); }

static void applyBit(ll idx, bool open) {
    if (knownBit[idx]) return;
    knownBit[idx] = 1;
    if (!open) return;
    EdgeI e = edgeInfo(idx);
    if (e.dir == 'R')
        openR[e.u] = 1;
    else
        openD[e.u] = 1;
    dsu->uni(e.u, e.v);
}

static string buildPath() {
    int R = (int)(m * m), target = R - 1;
    vector<int> par(R, -1);
    vector<char> pd(R, 0);
    deque<int> q;
    par[0] = 0;
    q.push_back(0);
    int mm = (int)m;
    while (!q.empty()) {
        int u = q.front();
        q.pop_front();
        if (u == target) break;
        int r = u / mm, c = u % mm;
        if (c + 1 < mm && openR[u] && par[u + 1] < 0) {
            par[u + 1] = u; pd[u + 1] = 'R'; q.push_back(u + 1);
        }
        if (r + 1 < mm && openD[u] && par[u + mm] < 0) {
            par[u + mm] = u; pd[u + mm] = 'D'; q.push_back(u + mm);
        }
        if (c > 0 && openR[u - 1] && par[u - 1] < 0) {
            par[u - 1] = u; pd[u - 1] = 'L'; q.push_back(u - 1);
        }
        if (r > 0 && openD[u - mm] && par[u - mm] < 0) {
            par[u - mm] = u; pd[u - mm] = 'U'; q.push_back(u - mm);
        }
    }
    if (par[target] < 0) return "";
    string dirs;
    for (int cur = target; cur != 0; cur = par[cur]) dirs.push_back(pd[cur]);
    reverse(dirs.begin(), dirs.end());
    string out;
    out.reserve(dirs.size() * 2);
    for (char c : dirs) {
        out.push_back(c);
        out.push_back(c);
    }
    return out;
}

[[noreturn]] static void claimAndExit() {
    wr("! " + buildPath());
    exit(0);
}

static void runRoot(const vector<ll>& p) {
    vector<ll> S(A + 1, 0);
    for (int i = 0; i < A; ++i) S[i + 1] = S[i] + p[i];

    {
        Infer inf((int)(m * m));
        for (ll t = 0; t < p[0]; ++t) {
            EdgeI e = edgeInfo(t);
            auto [open, queried] = inf.resolve(e);
            (void)queried;
            applyBit(t, open);
            if (open && connectedSG()) claimAndExit();
        }
    }

    vector<ll> bitsGot(A, 0), msgsExp(A, 0);
    ll totMsgs = 0;
    for (int i = 1; i < A; ++i) {
        ll chars = (p[i] + 5) / 6;
        msgsExp[i] = (chars + B - 1) / B;
        totMsgs += msgsExp[i];
    }
    ll gotMsgs = 0;
    int miss = 0;
    while (gotMsgs < totMsgs) {
        wr("< ?");
        string line = rd();
        if (!line.empty() && line[0] == '-') {  // "- -": nothing yet
            if (++miss > 300) break;            // a worker probably died
            continue;
        }
        miss = 0;
        size_t sp = line.find(' ');
        if (sp == string::npos) continue;
        int snd = atoi(line.substr(0, sp).c_str());
        if (snd < 1 || snd >= A) continue;
        ++gotMsgs;
        for (size_t ci = sp + 1; ci < line.size(); ++ci) {
            int v = VAL[(unsigned char)line[ci]];
            if (v < 0) continue;
            for (int b = 0; b < 6 && bitsGot[snd] < p[snd]; ++b, ++bitsGot[snd])
                applyBit(S[snd] + bitsGot[snd], (v >> b) & 1);
        }
        if (connectedSG()) claimAndExit();
    }

    // Fallback: some data never arrived; probe every still-unknown door.
    for (ll idx = 0; idx < E; ++idx) {
        if (knownBit[idx]) continue;
        EdgeI e = edgeInfo(idx);
        applyBit(idx, probeCell(e.qr, e.qc));
        if (connectedSG()) claimAndExit();
    }
    claimAndExit();
}

int main() {
    fill(begin(VAL), end(VAL), -1);
    for (int i = 0; i < 64; ++i) VAL[(unsigned char)ALPH[i]] = i;

    string first = rd();
    if (sscanf(first.c_str(), "%d %d %d %d", &N, &A, &ID, &B) != 4) return 0;
    m = (N + 1) / 2;
    E = 2 * m * (m - 1);
    L = 6LL * B;

    if (E == 0) {  // N == 1
        if (ID == 0) wr("! ");
        return 0;
    }

    buildPerm();
    vector<ll> p = computeSchedule();
    if (ID == 0) {
        knownBit.assign(E, 0);
        openR.assign(m * m, 0);
        openD.assign(m * m, 0);
        dsu = new DSU((int)(m * m));
        runRoot(p);
    } else {
        ll S = 0;
        for (int i = 0; i < ID; ++i) S += p[i];
        runWorker(S, p[ID]);
    }
    return 0;
}