```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	readInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	if scanner.Scan() {
		t, _ := strconv.Atoi(scanner.Text())
		dp := make([]int, 256)

		for i := 0; i < t; i++ {
			n := readInt()
			a := make([]int, n)
			for j := 0; j < n; j++ {
				a[j] = readInt()
			}

			maxLen := 0
			// The condition a_i ^ j < a_j ^ i can only hold if i and j share the same bits
			// from bit 8 upwards (since a_i <= 200 < 256).
			// This means valid subsequences must be contained entirely within blocks of
			// indices [k*256, (k+1)*256 - 1].
			for start := 0; start < n; start += 256 {
				end := start + 256
				if end > n {
					end = n
				}
				sz := end - start

				localMax := 0
				for k := 0; k < sz; k++ {
					dp[k] = 1
					u := start + k
					valU := a[u]
					for p := 0; p < k; p++ {
						v := start + p
						valV := a[v]
						// Check condition: a[v] ^ u < a[u] ^ v
						if (valV ^ u) < (valU ^ v) {
							if dp[p]+1 > dp[k] {
								dp[k] = dp[p] + 1
							}
						}
					}
					if dp[k] > localMax {
						localMax = dp[k]
					}
				}
				if localMax > maxLen {
					maxLen = localMax
				}
			}
			fmt.Fprintln(writer, maxLen)
		}
	}
}
```