from sys import stdin

DELTAS = [(+1, +1), (0, +1), (-1, 0), (-1, -1), (0, -1), (+1, 0)]
CORNER_MASK = 0b10101010101
SIDE_MASK = CORNER_MASK << 1

class Board:
    def __init__(self, S):
        self.S = S
        self.D = S * 2 - 1
        self.rep = [[None] * self.D for _ in range(self.D)]

    def which_corner_or_side(self, x, y):
        corner = (0  if x == self.D and y == self.D else
                  2  if x == self.S and y == self.D else
                  4  if x ==      1 and y == self.S else
                  6  if x ==      1 and y ==      1 else
                  8  if x == self.S and y ==      1 else
                  10 if x == self.D and y == self.S else
                  None)
        if corner is not None:
            return 1 << corner
        side = (1  if y == self.D and x >= self.S else
                3  if x + self.S - 1 == y else
                5  if x == 1 and y <= self.S else
                7  if y == 1 and x <= self.S else
                9  if y + self.S - 1 == x else
                11 if x == self.D and y >= self.S else
                None)
        if side is not None:
            return 1 << side
        return None
    
    def dist_to_center(self, x, y):
        dx, dy = x - self.S, y - self.S
        return max(dx, dy, 0) - min(dx, dy, 0)
        
    def mark(self, x, y):
        assert self.rep[x - 1][y - 1] is None
        corner_or_side = self.which_corner_or_side(x, y)
        self.rep[x - 1][y - 1] = corner_or_side if corner_or_side is not None else (x, y)
        return self.rep[x - 1][y - 1]
    
    def is_onboard(self, x, y):
        return 1 <= x <= self.D and 1 <= y <= self.D and abs(x - y) < self.S
    
    def has_parent(self, x, y):
        self_rep = self.rep[x - 1][y - 1]
        return self_rep is not None and not isinstance(self_rep, int) and self_rep != (x, y)
            
    def find(self, x, y):
        if not self.is_onboard(x, y):
            return None
        if not self.has_parent(x, y):
            return self.rep[x - 1][y - 1]
        self.rep[x - 1][y - 1] = self.find(*self.rep[x - 1][y - 1])
        return self.rep[x - 1][y - 1]
    
    def propagate(self, x, y, rep_value):
        while True:
            old_rep_value = self.rep[x - 1][y - 1]
            self.rep[x - 1][y - 1] = rep_value
            if self.has_parent(x, y):
                x, y = old_rep_value
            else:
                break
        
    def union(self, x1, y1, x2, y2):
        rep1 = self.find(x1, y1)
        assert rep1 is not None
        rep2 = self.find(x2, y2)
        assert rep2 is not None
        if isinstance(rep1, int):
            merged = rep1 | rep2 if isinstance(rep2, int) else rep1
        else:
            merged = rep2 if isinstance(rep2, int) else (rep1 if self.dist_to_center(*rep1) >= self.dist_to_center(*rep2) else rep2)
        if rep1 != merged:
            self.propagate(x1, y1, merged)
        if rep2 != merged:
            self.propagate(x2, y2, merged)
        
if __name__ == "__main__":
    T = int(stdin.readline())
    for t in range(T):
        S, M = map(int, stdin.readline().split())
        board = Board(S)
        result = ""
        for k in range(M):
            x, y = map(int, stdin.readline().split())
            if result:
                continue
            if board.find(x, y) is not None:
                continue
            wins = []
            neigh_reps = []
            dx, dy = DELTAS[-1]
            last_neigh_rep = board.find(x + dx, y + dy)
            for dx, dy in DELTAS:
                neigh_rep = board.find(x + dx, y + dy)
                if last_neigh_rep is None and neigh_rep is not None:
                    neigh_reps.append(neigh_rep)
                last_neigh_rep = neigh_rep
            if len(neigh_reps) > 1 and any(i for i in range(len(neigh_reps)) if neigh_reps[i-1] == neigh_reps[i]):
                wins.append("ring")
            self_rep = board.mark(x, y)
            for dx, dy in DELTAS:
                nx, ny = x + dx, y + dy
                if board.find(nx, ny) is None:
                    continue
                board.union(x, y, nx, ny)
            self_rep = board.find(x, y)
            if isinstance(self_rep, int):
                if (self_rep & CORNER_MASK).bit_count() >= 2:
                    wins.append("bridge")
                if (self_rep & SIDE_MASK).bit_count() >= 3:
                    wins.append("fork")
            if wins:
                wins.sort()
                result =f"{'-'.join(wins)} in move {k + 1}"
        if not result:
            result = "none"
        print(f"Case #{t + 1}: {result}")