```go
package main

import (
	"fmt"
	"sort"
)

type Query struct {
	u, v int
}

func find(i int, parent []int) int {
	if parent[i] == i {
		return i
	}
	parent[i] = find(parent[i], parent)
	return parent[i]
}

func merge(u, v int, parent []int, neq [][]bool) {
	ru := find(u, parent)
	rv := find(v, parent)
	if ru != rv {
		parent[ru] = rv
		n := len(parent) - 1
		for i := 1; i <= n; i++ {
			if neq[ru][i] {
				neq[rv][i] = true
				neq[i][rv] = true
			}
		}
	}
}

func infer(n int, parent []int, neq [][]bool) {
	changed := true
	for changed {
		changed = false
		roots := []int{}
		for i := 1; i <= n; i++ {
			if parent[i] == i {
				roots = append(roots, i)
			}
		}

		var cliques [][3]int
		for i := 0; i < len(roots); i++ {
			for j := i+1; j < len(roots); j++ {
				if neq[roots[i]][roots[j]] {
					for k := j+1; k < len(roots); k++ {
						if neq[roots[i]][roots[k]] && neq[roots[j]][roots[k]] {
							cliques = append(cliques, [3]int{roots[i], roots[j], roots[k]})
						}
					}
				}
			}
		}

		for _, X := range roots {
			for _, clique := range cliques {
				A, B, C := clique[0], clique[1], clique[2]
				rX, rA, rB, rC := find(X, parent), find(A, parent), find(B, parent), find(C, parent)
				
				if rX != rC && neq[rX][rA] && neq[rX][rB] {
					merge(X, C, parent, neq)
					changed = true
					break
				}
				if rX != rB && neq[rX][rA] && neq[rX][rC] {
					merge(X, B, parent, neq)
					changed = true
					break
				}
				if rX != rA && neq[rX][rB] && neq[rX][rC] {
					merge(X, A, parent, neq)
					changed = true
					break
				}
			}
			if changed {
				break
			}
		}
	}
}

func solve() {
	var n int
	if _, err := fmt.Scan(&n); err != nil {
		return
	}

	parent := make([]int, n+1)
	for i := 1; i <= n; i++ {
		parent[i] = i
	}

	neq := make([][]bool, n+1)
	for i := 0; i <= n; i++ {
		neq[i] = make([]bool, n+1)
	}

	for batch := 0; batch < 7; batch++ {
		infer(n, parent, neq)

		roots := []int{}
		size := make(map[int]int)
		for i := 1; i <= n; i++ {
			r := find(i, parent)
			size[r]++
			if parent[i] == i {
				roots = append(roots, i)
			}
		}

		sort.Slice(roots, func(i, j int) bool {
			return size[roots[i]] > size[roots[j]]
		})

		unassigned := make(map[int]bool)
		for _, r := range roots {
			unassigned[r] = true
		}

		var Groups [][]int
		for len(unassigned) > 0 {
			var group []int
			var C1 int
			for _, r := range roots {
				if unassigned[r] {
					C1 = r
					break
				}
			}
			group = append(group, C1)
			unassigned[C1] = false

			for _, C2 := range roots {
				if unassigned[C2] {
					ok := true
					for _, g := range group {
						if !neq[C2][g] {
							ok = false
							break
						}
					}
					if ok {
						group = append(group, C2)
						unassigned[C2] = false
						if len(group) == 3 {
							break
						}
					}
				}
			}
			Groups = append(Groups, group)
		}

		unused := make(map[int][]int)
		for i := 1; i <= n; i++ {
			r := find(i, parent)
			unused[r] = append(unused[r], i)
		}

		var queries []Query
		for i := 0; i < len(Groups); i++ {
			for j := i + 1; j < len(Groups); j++ {
				for _, A := range Groups[i] {
					for _, B := range Groups[j] {
						if !neq[A][B] {
							if len(unused[A]) > 0 && len(unused[B]) > 0 {
								u := unused[A][0]
								v := unused[B][0]
								unused[A] = unused[A][1:]
								unused[B] = unused[B][1:]
								queries = append(queries, Query{u, v})
							}
						}
					}
				}
			}
		}

		if len(queries) == 0 {
			break
		}

		fmt.Printf("Q %d", len(queries))
		for _, q := range queries {
			fmt.Printf(" %d %d", q.u, q.v)
		}
		fmt.Println()

		var resp string
		fmt.Scan(&resp)

		for k, q := range queries {
			if resp[k] == '1' {
				merge(q.u, q.v, parent, neq)
			} else {
				ru := find(q.u, parent)
				rv := find(q.v, parent)
				neq[ru][rv] = true
				neq[rv][ru] = true
			}
		}
	}

	infer(n, parent, neq)

	finalRoots := []int{}
	for i := 1; i <= n; i++ {
		if parent[i] == i {
			finalRoots = append(finalRoots, i)
		}
	}

	piles := make([][]int, 3)
	for idx, r := range finalRoots {
		if idx < 3 {
			for i := 1; i <= n; i++ {
				if find(i, parent) == r {
					piles[idx] = append(piles[idx], i)
				}
			}
		}
	}

	fmt.Println("A")
	for i := 0; i < 3; i++ {
		if len(piles[i]) == 0 {
			fmt.Println()
		} else {
			for j, v := range piles[i] {
				if j > 0 {
					fmt.Print(" ")
				}
				fmt.Print(v)
			}
			fmt.Println()
		}
	}
}

func main() {
	var t int
	if _, err := fmt.Scan(&t); err != nil {
		return
	}
	for i := 0; i < t; i++ {
		solve()
	}
}
```