```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

var in = bufio.NewReaderSize(os.Stdin, 1<<20)
var out = bufio.NewWriterSize(os.Stdout, 1<<20)

func ask(a, b, c int) int {
	fmt.Fprintf(out, "? %d %d %d\n", a, b, c)
	out.Flush()
	var x int
	fmt.Fscan(in, &x)
	if x == -1 {
		os.Exit(0)
	}
	return x
}

func answer(ans []int, n int) {
	fmt.Fprint(out, "!")
	for i := 1; i <= n; i++ {
		fmt.Fprintf(out, " %d", ans[i])
	}
	fmt.Fprint(out, "\n")
	out.Flush()
	var ok int
	fmt.Fscan(in, &ok)
	if ok != 1 {
		os.Exit(0)
	}
}

func med(x, y, z int) int {
	if x > y {
		x, y = y, x
	}
	if y > z {
		y, z = z, y
	}
	if x > y {
		x, y = y, x
	}
	if y-x > z-y {
		return y - x
	}
	return z - y
}

func fRel(d, y int) int {
	if y < 0 {
		if -y > d {
			return -y
		}
		return d
	}
	if y > d {
		if y-d > d {
			return y - d
		}
		return d
	}
	if y > d-y {
		return y
	}
	return d - y
}

func solveD1(n int, q1 []int) {
	cand := make([]int, 0, 2)
	x2 := 0
	for i := 3; i <= n; i++ {
		if q1[i] == 1 {
			cand = append(cand, i)
		}
		if q1[i] == 2 && x2 == 0 {
			x2 = i
		}
	}

	idxA2 := 0
	idxAm1 := 0
	for _, c := range cand {
		r := ask(1, c, x2)
		if r == 2 {
			idxA2 = c
		} else {
			idxAm1 = c
		}
	}

	q2 := make([]int, n+1)
	offset := make([]int, n+1)

	if idxA2 != 0 {
		for i := 1; i <= n; i++ {
			if i == 2 || i == idxA2 {
				continue
			}
			q2[i] = ask(2, idxA2, i)
		}
		offset[1] = 0
		offset[2] = 1
		offset[idxA2] = 2
		for i := 1; i <= n; i++ {
			if i == 1 || i == 2 || i == idxA2 {
				continue
			}
			u, v := q1[i], q2[i]
			if v == u+1 {
				offset[i] = -u
			} else {
				offset[i] = u + 1
			}
		}
	} else {
		if idxAm1 == 0 && len(cand) > 0 {
			idxAm1 = cand[0]
		}
		for i := 1; i <= n; i++ {
			if i == 1 || i == idxAm1 {
				continue
			}
			q2[i] = ask(idxAm1, 1, i)
		}
		offset[idxAm1] = -1
		offset[1] = 0
		offset[2] = 1
		for i := 1; i <= n; i++ {
			if i == 1 || i == 2 || i == idxAm1 {
				continue
			}
			u, v := q1[i], q2[i]
			if u == v+1 {
				offset[i] = -u
			} else {
				offset[i] = v
			}
		}
	}

	minY := offset[1]
	for i := 2; i <= n; i++ {
		if offset[i] < minY {
			minY = offset[i]
		}
	}
	A := 1 - minY

	ans := make([]int, n+1)
	for i := 1; i <= n; i++ {
		ans[i] = A + offset[i]
	}
	answer(ans, n)
}

func solveCase(n int) {
	q1 := make([]int, n+1)
	cnt1 := make([]int, n+1)
	minq := n + 1

	for i := 3; i <= n; i++ {
		q := ask(1, 2, i)
		q1[i] = q
		cnt1[q]++
		if q < minq {
			minq = q
		}
	}

	D := 2*minq - 1
	if cnt1[minq] == 1 {
		D = 2 * minq
	}

	if D == 1 {
		solveD1(n, q1)
		return
	}

	cand := make([]int, 0, 2)
	for i := 3; i <= n; i++ {
		if q1[i] == D-1 {
			cand = append(cand, i)
		}
	}

	idxA1 := 0
	if D == 2 {
		idxA1 = cand[0]
	} else if D == 3 {
		x := 0
		for i := 3; i <= n; i++ {
			if q1[i] > 3 {
				x = i
				break
			}
		}
		a0 := ask(1, cand[0], x)
		b0 := ask(2, cand[0], x)
		a1 := ask(1, cand[1], x)
		b1 := ask(2, cand[1], x)
		if a0 != a1 {
			if a0 > a1 {
				idxA1 = cand[0]
			} else {
				idxA1 = cand[1]
			}
		} else {
			if b0 < b1 {
				idxA1 = cand[0]
			} else {
				idxA1 = cand[1]
			}
		}
	} else {
		mid := 0
		for i := 3; i <= n; i++ {
			if q1[i] == minq {
				mid = i
				break
			}
		}
		r0 := ask(1, cand[0], mid)
		r1 := ask(1, cand[1], mid)
		if r0 < r1 {
			idxA1 = cand[0]
		} else {
			idxA1 = cand[1]
		}
	}

	q2 := make([]int, n+1)
	for i := 1; i <= n; i++ {
		if i == 1 || i == idxA1 {
			continue
		}
		q2[i] = ask(1, idxA1, i)
	}

	offset := make([]int, n+1)
	offset[1] = 0
	offset[idxA1] = 1
	offset[2] = D

	amb := make([]int, 0, 2)

	for i := 1; i <= n; i++ {
		if i == 1 || i == 2 || i == idxA1 {
			continue
		}
		s := q2[i]
		poss := 0
		val := 0

		y := -s
		if fRel(D, y) == q1[i] {
			poss++
			val = y
		}

		y = 1 + s
		if y != D && fRel(D, y) == q1[i] {
			if poss == 0 {
				val = y
			}
			poss++
		}

		if poss == 1 {
			offset[i] = val
		} else {
			amb = append(amb, i)
		}
	}

	for _, i := range amb {
		r := ask(2, idxA1, i)
		if r > D {
			offset[i] = -D
		} else {
			offset[i] = D + 1
		}
	}

	minY := offset[1]
	for i := 2; i <= n; i++ {
		if offset[i] < minY {
			minY = offset[i]
		}
	}
	A := 1 - minY

	ans := make([]int, n+1)
	for i := 1; i <= n; i++ {
		ans[i] = A + offset[i]
	}
	answer(ans, n)
}

func main() {
	defer out.Flush()
	var t int
	fmt.Fscan(in, &t)
	for ; t > 0; t-- {
		var n int
		fmt.Fscan(in, &n)
		solveCase(n)
	}
}
```