#include <bits/stdc++.h>

typedef long long ll;
typedef unsigned long long ull;
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define ROF(i, a, b) for (int i = a; i >= b; --i)
#define NEXT(i, r, v) for (int i = h[r], v; v = e[i].v, i; i = e[i].u)
const int INF = 2e9;

inline int Max(const int &a, const int &b) { return a > b ? a : b; }
inline int Min(const int &a, const int &b) { return a > b ? b : a; }

inline int read() {
    int f = 1, x = 0;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}

#ifndef __x86_64__
#error Only x86-64 targets are supported
#endif
#include <cstdint>
#include <iosfwd>
#include <string>
#include <vector>
#define __builtin_ia32_adc(x, y, flag) \
    __asm__(                           \
        "addb   %3, %0\n\t"            \
        "adcq   %2, %1\n\t"            \
        "setc   %0"                    \
        : "+r"(flag), "+r"(x)          \
        : "r"(y), "i"(-1)              \
        : "cc")

struct bigint {  // made by dengyaotriangle!
    typedef unsigned long long u64;
    typedef unsigned __int128 u128;
    typedef std::size_t st;
    std::vector<u64> data;
    bigint() {}
    bigint(u64 x) : data(x ? std::vector<u64>{x} : std::vector<u64>{}) {}
    bigint(const std::string &s) {
        st pos = s.length();
        int cnt = 0;
        u64 val = 0;
        while (pos) {
            pos--;
            if (cnt == 64) {
                data.push_back(val);
                val = 0;
                cnt = 0;
            }
            val |= (u64)(s[pos] == '1') << cnt;
            ++cnt;
        }
        if (cnt && val) data.push_back(val);
    }
    explicit operator std::string() const {
        if (data.empty()) return "0";
        bool t = 0;
        std::string ret;
        for (int i = 63; i >= 0; i--) {
            t |= (data.back() >> i) & 1;
            if (t) ret += '0' | ((data.back() >> i) & 1);
        }
        st i = data.size() - 1;
        while (i) {
            i--;
            for (int j = 63; j >= 0; j--) ret += '0' | ((data[i] >> j) & 1);
        }
        return ret;
    }
    explicit operator bool() const { return !data.empty(); }
    explicit operator u64() const { return data.empty() ? 0 : data[0]; }
    st digit() const {
        if (data.empty()) return 0;
        return (data.size() << 6) - __builtin_clzll(data.back());
    }
    bool operator==(const bigint &a) const { return a.data == data; }
    bool operator!=(const bigint &a) const { return a.data != data; }
    bool operator<(const bigint &a) const {
        if (data.size() != a.data.size()) return data.size() < a.data.size();
        for (st i = data.size(); i;) {
            i--;
            if (data[i] != a.data[i]) return data[i] < a.data[i];
        }
        return 0;
    }
    bool operator>(const bigint &a) const { return a < (*this); }
    bool operator<=(const bigint &a) const { return !(*this > a); }
    bool operator>=(const bigint &a) const { return !(*this < a); }
    bigint &operator<<=(st n) {
        if (data.empty()) return *this;
        int w = n & 63;
        st z = n >> 6;
        st i = data.size();
        bool flg = 0;
        if (w && (data.back() >> (64 - w))) data.push_back(0), flg = 1;
        data.resize(data.size() + z);
        while (i) {
            i--;
            if (flg) data[i + z + 1] |= data[i] >> (64 - w);
            data[i + z] = data[i] << w;
            flg |= bool(w);
        }
        for (st i = 0; i < z; i++) data[i] = 0;
        return *this;
    }
    bigint &operator>>=(st n) {
        int w = n & 63;
        st z = n >> 6, i = 0;
        for (; i + z < data.size(); i++) {
            if (w && i) data[i - 1] |= data[i + z] << (64 - w);
            data[i] = data[i + z] >> w;
        }
        while (data.size() > i) data.pop_back();
        while (!data.empty() && data.back() == 0) data.pop_back();
        return *this;
    }
    bigint operator<<(st n) const { return bigint(*this) <<= n; }
    bigint operator>>(st n) const { return bigint(*this) >>= n; }
    bigint &operator+=(const bigint &a) {
        data.resize(std::max(data.size(), a.data.size()));
        bool carry = 0;
        for (st i = 0; i < data.size(); i++) {
            u64 rg = 0;
            if (i < a.data.size()) rg = a.data[i];
            __builtin_ia32_adc(data[i], rg, carry);
        }
        if (carry) data.push_back(1);
        return *this;
    }
    bigint &operator-=(const bigint &a) {
        bool carry = 1;
        for (st i = 0; i < data.size(); i++) {
            u64 rg = -1;
            if (i < a.data.size()) rg = ~a.data[i];
            __builtin_ia32_adc(data[i], rg, carry);
        }
        while (!data.empty() && data.back() == 0) data.pop_back();
        return *this;
    }
    bigint &operator++() { return *this += bigint(1); }
    bigint &operator--() { return *this -= bigint(1); }
    bigint operator++(int) {
        bigint tmp = *this;
        ++*this;
        return tmp;
    }
    bigint operator--(int) {
        bigint tmp = *this;
        --*this;
        return tmp;
    }
    bigint &operator*=(const bigint &a) {
        std::vector<u64> ret(data.size() + a.data.size());
        for (st i = 0; i < data.size(); i++) {
            u64 carry = 0;
            bool wcarry = 0;
            st k = i;
            for (st j = 0; j < a.data.size(); j++, k++) {
                u128 r = data[i] * (u128)a.data[j] + carry;
                u64 cur = r;
                carry = r >> 64;
                __builtin_ia32_adc(ret[k], cur, wcarry);
            }
            while (carry || wcarry) {
                __builtin_ia32_adc(ret[k], carry, wcarry);
                carry = 0;
                k++;
            }
        }
        while (!ret.empty() && ret.back() == 0) ret.pop_back();
        data = ret;
        return *this;
    }
    bigint &operator/=(const bigint &a) {
        if (a.digit() > digit()) {
            data.clear();
            return *this;
        }
        st z = digit() - a.digit();
        std::vector<u64> ret;
        while (1) {
            bigint tmp = a << z;
            if (tmp <= *this) {
                *this -= tmp;
                st v1 = z >> 6;
                if (ret.size() <= v1) ret.resize(v1 + 1);
                ret[v1] |= (u64)(1) << (z & 63);
            }
            if (!z) break;
            z--;
        }
        data = ret;
        return *this;
    }
    bigint &operator%=(const bigint &a) {
        if (a.digit() > digit()) return *this;
        st z = digit() - a.digit();
        while (1) {
            bigint tmp = a << z;
            if (tmp <= *this) *this -= tmp;
            if (!z) break;
            z--;
        }
        return *this;
    }
    bigint operator+(const bigint &a) const { return bigint(*this) += a; }
    bigint operator-(const bigint &a) const { return bigint(*this) -= a; }
    bigint operator*(const bigint &a) const { return bigint(*this) *= a; }
    bigint operator/(const bigint &a) const { return bigint(*this) /= a; }
    bigint operator%(const bigint &a) const { return bigint(*this) %= a; }
};
std::istream &operator>>(std::istream &st, bigint &a) {
    std::string s;
    st >> s;
    a = bigint(s);
    return st;
}
std::ostream &operator<<(std::ostream &st, const bigint &a) { return st << (std::string)(a); }

const int N = 605;
using namespace std;
int n, m;
char s[N], t[N];
bigint f[N][N], g[N][N];
void initf(int n) {
    f[n][n / 2] = 1;
    ROF(i, n - 1, 0) {
        int mx = Min(i, n / 2);
        FOR(j, 0, mx) { f[i][j] = f[i + 1][j] + f[i + 1][j + 1]; }
    }
}
void initg(int n) {
    g[n][0] = 1;
    ROF(i, n - 1, 0) {
        int mx = Min(i, n / 2);
        g[i][0] = g[i + 1][1];
        FOR(j, 1, mx) { g[i][j] = g[i + 1][j - 1] + g[i + 1][j + 1]; }
    }
}
void path() {
    n = read(), m = 2 * n;
    initf(m), initg(m);
    scanf("%s", s + 1);
    bigint x = 0;
    int now = 0, res = 0;
    FOR(i, 1, m) {
        if (s[i] == 'U') {
            x += f[i][now + 1];
        } else {
            ++now;
        }
    }
    res = ull(x % (n + 1));
    x /= (n + 1);
    now = 0;
    FOR(i, 1, m) {
        if (g[i][now + 1] > x) {
            t[i] = '(', ++now;
        } else {
            x -= g[i][now + 1];
            t[i] = ')', --now;
        }
    }
    printf("%s\n", t + 1);
    printf("%d\n", res);
}
void brackets() {
    n = read(), m = 2 * n;
    initf(m), initg(m);
    scanf("%s", s + 1);
    bigint x = 0;
    int now = 0, res = 0;
    FOR(i, 1, m) {
        if (s[i] == ')') {
            x += g[i][now + 1];
            --now;
        } else {
            ++now;
        }
    }
    x = x * (n + 1) + read();
    now = 0;
    FOR(i, 1, m) {
        if (f[i][now + 1] > x) {
            t[i] = 'R', ++now;
        } else {
            x -= f[i][now + 1];
            t[i] = 'U';
        }
    }
    printf("%s\n", t + 1);
}
char ch[20];
int main() {
    scanf("%s", ch + 1);
    if (ch[1] == 'p') {
        path();
    } else {
        brackets();
    }
    return 0;
}