package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
	"strings"
)

type Seg struct {
	l int
	r int
}

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n {
		b := fs.data[fs.idx]
		if (b >= '0' && b <= '9') || b == '-' {
			break
		}
		fs.idx++
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n {
		b := fs.data[fs.idx]
		if b < '0' || b > '9' {
			break
		}
		val = val*10 + int(b-'0')
		fs.idx++
	}
	return sign * val
}

func weighted(cand []int, segs []Seg, w []int) int {
	if len(cand) == 0 {
		return 0
	}
	sort.Slice(cand, func(a, b int) bool {
		ia, ib := cand[a], cand[b]
		if segs[ia].r != segs[ib].r {
			return segs[ia].r < segs[ib].r
		}
		return segs[ia].l < segs[ib].l
	})
	m := len(cand)
	rights := make([]int, m)
	dp := make([]int, m+1)
	for i, idx := range cand {
		rights[i] = segs[idx].r
	}
	for i := 1; i <= m; i++ {
		idx := cand[i-1]
		left := segs[idx].l
		p := sort.Search(i-1, func(u int) bool {
			return rights[u] >= left
		})
		val := dp[p] + w[idx]
		if dp[i-1] > val {
			dp[i] = dp[i-1]
		} else {
			dp[i] = val
		}
	}
	return dp[m]
}

func main() {
	fs := NewFastScanner()
	t := fs.NextInt()
	var out strings.Builder

	for tc := 0; tc < t; tc++ {
		n := fs.NextInt()
		segs := make([]Seg, n)
		for i := 0; i < n; i++ {
			segs[i] = Seg{l: fs.NextInt(), r: fs.NextInt()}
		}

		sort.Slice(segs, func(i, j int) bool {
			di := segs[i].r - segs[i].l
			dj := segs[j].r - segs[j].l
			if di != dj {
				return di < dj
			}
			if segs[i].l != segs[j].l {
				return segs[i].l < segs[j].l
			}
			return segs[i].r < segs[j].r
		})

		f := make([]int, n)
		cand := make([]int, 0, n)

		for i := 0; i < n; i++ {
			cand = cand[:0]
			for j := 0; j < i; j++ {
				if segs[i].l <= segs[j].l && segs[j].r <= segs[i].r {
					cand = append(cand, j)
				}
			}
			f[i] = 1 + weighted(cand, segs, f)
		}

		all := make([]int, n)
		for i := 0; i < n; i++ {
			all[i] = i
		}
		ans := weighted(all, segs, f)

		out.WriteString(strconv.Itoa(ans))
		if tc+1 < t {
			out.WriteByte('\n')
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.WriteString(out.String())
	w.Flush()
}