import sys

INF = 10**9 + 100
INFL = 3 * 10**18 + 100


class SegTree:
    def __init__(self, arr):
        n = len(arr)
        self._n = n
        self.size = 1
        while self.size < n:
            self.size <<= 1
        self.data = [0] * (2 * self.size)
        for i, v in enumerate(arr):
            self.data[self.size + i] = v
        for i in range(self.size - 1, 0, -1):
            self.data[i] = self.data[i << 1] + self.data[i << 1 | 1]

    def set(self, p, x):
        p += self.size
        self.data[p] = x
        p >>= 1
        while p:
            self.data[p] = self.data[p << 1] + self.data[p << 1 | 1]
            p >>= 1

    def max_right(self, l, f):
        if l == self._n:
            return self._n
        l += self.size
        sm = 0
        while True:
            while l % 2 == 0:
                l >>= 1
            if not f(sm + self.data[l]):
                while l < self.size:
                    l <<= 1
                    if f(sm + self.data[l]):
                        sm += self.data[l]
                        l += 1
                return l - self.size
            sm += self.data[l]
            l += 1
            if (l & -l) == l:
                break
        return self._n


def solve():
    input = sys.stdin.readline

    T = int(input())
    PRS = "PRS"

    def safe_pow2(n):
        if n > 60:
            return INFL
        return 1 << n

    def janken_win(a, b):
        if a == b:
            return -1
        if (a - b + 3) % 3 == 2:
            return a
        return b

    for _ in range(T):
        N, K = map(int, input().split())
        A = list(map(int, input().split()))

        if safe_pow2(N - 1) < K:
            print("-1")
            print("-1")
            print("-1")
            continue

        seg = SegTree([1] * N)
        idx = list(range(N))
        par = [-1] * (N * 2 - 1)
        subtree = [0] * (N * 2 - 1)
        for i in range(N):
            subtree[i] = 1
        child = [(-1, -1) for _ in range(N * 2 - 1)]

        for i in range(N - 1):
            l = seg.max_right(0, lambda x, ai=A[i]: x < ai)
            r = seg.max_right(0, lambda x, ai=A[i]: x < ai + 1)

            child[i + N] = (idx[l], idx[r])
            subtree[i + N] = subtree[idx[l]] + subtree[idx[r]]
            par[idx[l]] = i + N
            par[idx[r]] = i + N

            idx[l] = i + N
            idx[r] = -1
            seg.set(r, 0)

        sys.setrecursionlimit(1_000_000)

        def dfs(v, cnt, k_ref, res):
            k = k_ref[0]
            if child[v][0] == -1:
                for i in range(3):
                    if k <= cnt[i]:
                        res[v] = PRS[i]
                        k_ref[0] = k
                        return i
                    k -= cnt[i]
                raise AssertionError
            else:
                lch, rch = child[v]

                cntL = [0, 0, 0]
                mul = safe_pow2(subtree[rch] - 1)
                for i in range(3):
                    cntL[i] = min((cnt[i] + cnt[(i + 2) % 3]) * mul, INFL)

                l = dfs(lch, cntL, k_ref, res)

                cntR = [0, 0, 0]
                for i in range(3):
                    if i == l:
                        cntR[i] = 0
                    else:
                        cntR[i] = cnt[janken_win(l, i)]

                r = dfs(rch, cntR, k_ref, res)
                return janken_win(l, r)

        ans = [""] * N

        k_ref = [K]
        dfs(N * 2 - 2, [0, 1, 0], k_ref, ans)
        print("".join(ans))

        k_ref = [K]
        dfs(N * 2 - 2, [1, 0, 0], k_ref, ans)
        print("".join(ans))

        k_ref = [K]
        dfs(N * 2 - 2, [0, 0, 1], k_ref, ans)
        print("".join(ans))


if __name__ == "__main__":
    solve()