import sys
input = sys.stdin.read

INF = float('inf')

def solve():
    data = input().split()
    idx = 0
    C = int(data[idx])
    idx += 1

    results = []

    for _ in range(C):
        N = int(data[idx])
        T = int(data[idx+1])
        idx += 2

        tracks = []
        for _ in range(N):
            cp = int(data[idx])
            cbb = int(data[idx+1])
            cbe = int(data[idx+2])
            ceb = int(data[idx+3])
            cee = int(data[idx+4])
            idx += 5
            tracks.append((cp, cbb, cbe, ceb, cee))
            #print cp,cbb,cbe,ceb,cee

        dp = [[INF, INF] for _ in range(N)]
        prev_dir = [[-1, -1] for _ in range(N)]

        dp[0][0] = tracks[0][0]  # forward
        dp[0][1] = tracks[0][0]  # backward

        for i in range(1, N):
            cp, _, _, _, _ = tracks[i]
            prev_cp, cbb, cbe, ceb, cee = tracks[i-1]

            for last_dir in [0, 1]:
                if dp[i-1][last_dir] == INF:
                    continue

                # Try forward
                trans = ceb if last_dir == 0 else cbb
                total = dp[i-1][last_dir] + trans + cp
                if total < dp[i][0]:
                    dp[i][0] = total
                    prev_dir[i][0] = last_dir

                # Try backward
                trans = cee if last_dir == 0 else cbe
                total = dp[i-1][last_dir] + trans + cp
                if total < dp[i][1]:
                    dp[i][1] = total
                    prev_dir[i][1] = last_dir

                #print dp[i][0],dp[i][1]
                #print prev_dir[i][0],prev_dir[i][1]

        # Close the loop
        min_time = INF
        final_dir = -1

        last_cp, cbb, cbe, ceb, cee = tracks[N-1]

        for d in [0, 1]:
            if dp[N-1][d] == INF:
                continue

            # back to track 0
            for return_cost in [cee, ceb] if d == 0 else [cbe, cbb]:
                total_time = dp[N-1][d] + return_cost
                if total_time <= T and total_time < min_time:
                    min_time = total_time
                    final_dir = d

        if min_time == INF:
            results.append("IMPOSSIBLE")
            continue

        # reconstruct path
        path = [None] * N
        curr_dir = final_dir
        for i in range(N-1, -1, -1):
            path[i] = 'F' if curr_dir == 0 else 'B'
            curr_dir = prev_dir[i][curr_dir]

        results.append("".join(path))

    print("\n".join(results))

if __name__ == "__main__":
    solve()