There are $n$ models in the shop numbered from $1$ to $n$, with sizes $s_1, s_2, \ldots, s_n$.

Orac will buy some of the models and will arrange them in the order of increasing numbers (i.e. indices, but not sizes).

Orac thinks that the obtained arrangement is beatiful, if for any two adjacent models with indices $i_j$ and $i_{j+1}$ (note that $i_j < i_{j+1}$, because Orac arranged them properly), $i_{j+1}$ is divisible by $i_j$ and $s_{i_j} < s_{i_{j+1}}$.

For example, for $6$ models with sizes $\{3, 6, 7, 7, 7, 7\}$, he can buy models with indices $1$, $2$, and $6$, and the obtained arrangement will be beautiful. Also, note that the arrangement with exactly one model is also considered beautiful.

Orac wants to know the maximum number of models that he can buy, and he may ask you these queries many times.


-----Input-----

The first line contains one integer $t\ (1 \le t\le 100)$: the number of queries.

Each query contains two lines. The first line contains one integer $n\ (1\le n\le 100\,000)$: the number of models in the shop, and the second line contains $n$ integers $s_1,\dots,s_n\ (1\le s_i\le 10^9)$: the sizes of models.

It is guaranteed that the total sum of $n$ is at most $100\,000$.


-----Output-----

Print $t$ lines, the $i$-th of them should contain the maximum number of models that Orac can buy for the $i$-th query.


-----Example-----
Input
4
4
5 3 4 6
7
1 4 2 3 6 4 9
5
5 4 3 2 1
1
9

Output
2
3
1
1



-----Note-----

In the first query, for example, Orac can buy models with indices $2$ and $4$, the arrangement will be beautiful because $4$ is divisible by $2$ and $6$ is more than $3$. By enumerating, we can easily find that there are no beautiful arrangements with more than two models. 

In the second query, Orac can buy models with indices $1$, $3$, and $6$. By enumerating, we can easily find that there are no beautiful arrangements with more than three models. 

In the third query, there are no beautiful arrangements with more than one model.

Difficulty: MEDIUM

Solutions:
import math
t = int(input())

def divs(n):
	d = []
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			d.append(i)
			d.append(int(n / i))
	return d

def solve():
	n = int(input())
	ar = list(map(int, input().split()))
	maxes = []
	for i in range(len(ar)):
		d = divs(i + 1)
		m = 0
		for j in range(len(d)):
			if ar[d[j] - 1] < ar[i] and maxes[d[j] - 1] > m:
				m = maxes[d[j] - 1]
		maxes.append(m + 1)
	print(max(maxes))
for i in range(t):
	solve()


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
import sys
input = sys.stdin.readline
scanner = lambda : int(input())
string = lambda : input().rstrip()
get_list = lambda : list(read())
read = lambda : map(int, input().split())
get_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def is_integer(n):
	return math.ceil(n) == math.floor(n)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def next_prime(n, primes):
	while primes[n] != True:
		n += 1
	return n
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(moves, n):
	val = (moves + 1) // 2
	rem = moves - val
	sol = (val + 1) * (rem + 1)
	return sol < n

def sortSecond(val):
	return val[1]
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
alphs = 'abcdefghijklmnopqrstuvwxyz'
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect
import functools as fnt

def solve():
	q = scanner()
	a = get_list()
	dp = [1] * (q + 1)
	for i in range(q):
		for j in range(2 * i + 1, q, i + 1):
			if a[j] > a[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
t = scanner()
for i in range(t):
	solve()


import sys
input = sys.stdin.readline
ans = []
for T in range(int(input())):
	(n, lst) = (int(input()), list(map(int, input().split())))
	(dp, i) = (n * [1], 1)
	while i <= n:
		j = 2 * i
		while j <= n:
			if lst[i - 1] < lst[j - 1]:
				dp[j - 1] = max(dp[j - 1], dp[i - 1] + 1)
			j += i
		i += 1
	ans.append(max(dp))
print(*ans, sep='\n')


def func(dp, a, ind):
	if ind > n:
		return 0
	if dp[ind] != -1:
		return dp[ind]
	count = 0
	for i in range(ind, n + 1, ind):
		if a[i] > a[ind]:
			count = max(count, 1 + func(dp, a, i))
	dp[ind] = count
	return dp[ind]
t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	arr = [0]
	arr = arr + list(map(int, input().split(' ')))
	dp = [-1] * (len(arr) + 1)
	maxi = 1
	for i in range(1, n + 1):
		maxi = max(maxi, 1 + func(dp, arr, i))
	print(maxi)


t = int(input())
for _ in range(t):
	n = int(input())
	arr = [0] + list(map(int, input().split()))
	cnt = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2, n + 1):
			if i * j > n:
				break
			if arr[i] < arr[i * j]:
				cnt[i * j] = max(cnt[i * j], cnt[i] + 1)
	print(max(cnt))


import math

def check(n):
	ans = [1, n]
	for q in range(2, int(math.sqrt(n)) + 1):
		if n % q == 0:
			ans.append(q)
			ans.append(n // q)
	return ans
for _ in range(int(input())):
	n = int(input())
	data = [int(x) for x in input().split()]
	data.insert(0, 0)
	ans = [0]
	for q in range(1, n + 1):
		max = 1
		div = check(q)
		for w in div:
			if data[w] < data[q]:
				temp = ans[w] + 1
				if temp > max:
					max = temp
		ans.append(max)
	temp = 0
	for q in ans:
		if q > temp:
			temp = q
	print(temp)


for i in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.insert(0, 0)
	d = {}
	for i in range(1, n + 1):
		d[i] = 1
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j] > l[i]:
				d[j] = max(d[i] + 1, d[j])
	ans = 0
	for i in d:
		ans = max(ans, d[i])
	print(ans)


for _ in range(int(input())):
	arr = int(input())
	ans = 0
	a = list(map(int, input().split()))
	a.insert(0, 1)
	f = [1 for j in range(arr + 1)]
	for i in range(1, arr + 1):
		for j in range(i * 2, arr + 1, i):
			if a[i] < a[j]:
				f[j] = max(f[j], f[i] + 1)
	for i in range(1, arr + 1):
		ans = max(ans, f[i])
	print(ans)


import sys
input = sys.stdin.buffer.readline

def I():
	return list(map(int, input().split()))

def sieve(n):
	a = [1] * n
	for i in range(2, n):
		if a[i]:
			for j in range(i * i, n, i):
				a[j] = 0
	return a

def rec(i):
	if dp[i] != -1:
		return dp[i]
	m = 0
	for j in range(2 * i, n + 1, i):
		if arr[j] > arr[i]:
			m = max(rec(j), m)
	dp[i] = m + 1
	return dp[i]
for __ in range(int(input())):
	n = int(input())
	arr = [0] + I()
	dp = [-1] * (n + 1)
	for i in reversed(range(1, n + 1)):
		if dp[i] != -1:
			continue
		rec(i)
	print(max(dp))


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	arr = [0]
	arr.extend(list(map(int, input().split())))
	d = dict()
	ans = [1] * len(arr)
	for i in range(1, len(ans)):
		j = i
		while j + i < len(ans):
			j += i
			if arr[i] < arr[j]:
				if ans[i] + 1 > ans[j]:
					ans[j] = ans[i] + 1
	print(max(ans))


import sys
from math import ceil, sqrt
read = sys.stdin.buffer.readline
mi = lambda : map(int, read().split())
li = lambda : list(mi())
cin = lambda : int(read())
for _ in range(cin()):
	n = cin()
	a = li()
	vis = [1] * n
	i = 1
	while i + i <= n:
		j = i + i
		while j <= n:
			if a[j - 1] > a[i - 1]:
				vis[j - 1] = max(vis[j - 1], vis[i - 1] + 1)
			j += i
		i += 1
	print(max(vis))


import sys
input = sys.stdin.readline
from math import log2, log, ceil

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return res

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]
spf_sieve()

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
for _ in range(int(input())):
	n = int(input())
	v = [0] + int_array()
	arr = [1] * (n + 1)
	for i in range(2, n + 1):
		for j in range(1, int(n ** 0.5 + 1)):
			if i % j == 0:
				if v[i] > v[j]:
					arr[i] = max(arr[i], arr[j] + 1)
				if v[i] > v[i // j]:
					arr[i] = max(arr[i], arr[i // j] + 1)
	print(max(arr))


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		a = list(map(int, input().split()))
		end = n // 2
		if n % 2 != 0:
			end += 1
		d = {}
		for i in range(end):
			bi = i + 1
			if bi not in d:
				d[bi] = 1
			for j in range(bi * 2, n + 1, bi):
				if a[j - 1] > a[i]:
					if j not in d:
						d[j] = d[bi] + 1
					else:
						d[j] = max(d[j], d[bi] + 1)
		M = max(1, max(d.values()))
		print(M)
main()


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ans = [1] * n
	final = 0
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[i - 1] < a[j - 1]:
				ans[j - 1] = max(ans[j - 1], ans[i - 1] + 1)
		final = max(final, ans[i - 1])
	print(final)


from collections import defaultdict, Counter, deque
from math import inf, sqrt
from functools import lru_cache
from heapq import heappop, heappush, heapify
from bisect import bisect_left, bisect_right
import sys
Mod = 10 ** 9 + 7

def solution():
	n = int(input())
	arr = list(map(int, input().split()))
	arr = [-1] + arr
	dp = [1] * len(arr)
	for i in range(1, len(arr))[::-1]:
		for j in range(i + i, len(arr), i):
			if arr[i] < arr[j]:
				dp[i] = max(dp[i], dp[j] + 1)
	return print(max(dp))

def main():
	t = 1
	t = int(input())
	for _ in range(t):
		solution()
import sys
import threading
sys.setrecursionlimit(10 ** 6)
threading.stack_size(1 << 27)
thread = threading.Thread(target=main)
thread.start()
thread.join()


t = int(input())
for w in range(t):
	n = int(input())
	data = list(map(int, input().strip().split()))
	models = [1 for i in range(n)]
	for (i, value) in enumerate(data, start=1):
		r = models[i - 1]
		if 2 * i < n + 1:
			for j in range(2 * i - 1, n, i):
				if data[j] > value:
					models[j] = max(models[j], r + 1)
		else:
			break
	print(max(models))


n_cases = int(input())
for case_num in range(1, n_cases + 1):
	n = int(input())
	arr = [0] + [int(x) for x in input().split()]
	mat = [0] * (n + 1)
	for i in range(n, 0, -1):
		mat[i] = 1
		for j in range(2, 10 ** 9):
			if i * j > n:
				break
			if arr[i * j] > arr[i]:
				mat[i] = max(mat[i], 1 + mat[i * j])
	print(max(mat))


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		n = int(input())
		l = [0] + list(map(int, input().split()))
		dp = [1 for x in range(n + 1)]
		ans = 1
		for i in range(1, n + 1):
			t = i * 2
			while t <= n:
				if l[t] > l[i]:
					dp[t] = max(dp[i] + 1, dp[t])
					ans = max(ans, dp[t])
				t += i
		print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


t = int(input())
from collections import deque

def solve():
	n = int(input())
	As = list(map(int, input().split()))
	edges = [[] for i in range(n + 1)]
	q = deque([])
	for i in range(1, n + 1):
		cnt = i * 2
		while cnt <= n:
			edges[i].append(cnt)
			cnt += i
	dp = [1] * (n + 1)
	s = 1
	for i in range(1, n + 1):
		if dp[i] != 1:
			continue
		q.append(i)
		while len(q) > 0:
			v = q.pop()
			x = dp[v]
			for u in edges[v]:
				if As[u - 1] > As[v - 1]:
					q.append(u)
					dp[u] = max(dp[u], x + 1)
	return max(dp)
ans = []
for i in range(t):
	ans.append(solve())
for a in ans:
	print(a)


for __ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ans = [1] * n
	for i in range(1, n + 1):
		j = 2
		while i * j <= n:
			if a[i * j - 1] > a[i - 1]:
				ans[i * j - 1] = max(ans[i * j - 1], ans[i - 1] + 1)
			j += 1
	print(max(ans))


from sys import stdin
input = stdin.buffer.readline
for _ in range(int(input())):
	n = int(input())
	(*a,) = map(int, input().split())
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j - 1] > a[i - 1]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


def solve(arr, n, idx, dp):
	if idx > n:
		return 0
	if dp[idx] != -1:
		return dp[idx]
	count = 0
	for i in range(idx, n + 1, idx):
		if arr[i] > arr[idx]:
			count = max(count, 1 + solve(arr, n, i, dp))
	dp[idx] = count
	return count
t = int(input())
for t in range(0, t):
	dp = [-1 for i in range(0, 100004)]
	n = int(input())
	arr = list(map(int, input().strip().split()))
	arr1 = [-1 for i in range(0, n + 1)]
	for i in range(1, n + 1):
		arr1[i] = arr[i - 1]
	maxi = 1
	for i in range(1, n + 1):
		maxi = max(maxi, 1 + solve(arr1, n, i, dp))
	print(maxi)


def solve(n, s):
	dp = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		j = 1
		max_div = -1
		while j * j <= i:
			if i % j == 0:
				div_1 = j
				div_2 = i // j
				for div in [div_1, div_2]:
					if s[div - 1] < s[i - 1]:
						max_div = max(max_div, dp[div] + 1)
			j += 1
		dp[i] = max(1, max_div)
	res = max(dp)
	return res
t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	res = solve(n, s)
	print(res)


t = int(input())
for T in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	u = [1 for x in range(n + 1)]
	i = n // 2 + 1
	while i >= 1:
		j = 2
		maxi = 1
		while i * j < len(a):
			if u[i * j] + 1 > maxi and a[i * j] > a[i]:
				maxi = u[i * j] + 1
			j += 1
		u[i] = maxi
		i -= 1
	print(max(u))


def solution():
	n = int(input())
	s = list(map(lambda x: int(x), input().split()))
	d = [1] * n
	d.insert(0, 1)
	s.insert(0, -1)
	answer = 1
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i] < s[j]:
				d[j] = max(d[j], d[i] + 1)
				answer = max(answer, d[j])
	print(answer)
t = int(input())
for _ in range(t):
	solution()


for s in [*open(0)][2::2]:
	a = (*map(int, s.split()),)
	n = i = len(a)
	r = [1] * n
	while i:
		i -= 1
		r[i] = max((r[j] * (a[i] < a[j]) + 1 for j in range(i, n, i + 1)))
	print(max(r))


t = int(input())
for r in range(t):
	n = int(input())
	S = list(map(int, input().split()))
	A = [1] * n
	ma = 1
	for i in range(0, n):
		k = i + 1
		l = k + k
		while l <= n:
			if S[l - 1] > S[i]:
				if A[l - 1] < A[i] + 1:
					A[l - 1] = A[i] + 1
			l = l + k
		if i + i >= n:
			break
	print(max(A))


t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().strip().split()))
	result = [1] * len(s)
	for i in range(len(s)):
		indeks = i + 1
		start = 2 * indeks
		while start <= n:
			if s[start - 1] > s[i]:
				result[start - 1] = max(result[start - 1], result[i] + 1)
			start += indeks
	print(max(result))


for _ in range(int(input())):
	n = int(input())
	ar = [0] + list(map(int, input().split()))
	dp = [0] * (n + 1)
	for i in range(1, n + 1):
		dp[i] = max(1, dp[i])
		for j in range(i + i, n + 1, i):
			if ar[j] > ar[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


def solve(size, array):
	count = [1] * (size + 1)
	for i in range(1, size + 1, 1):
		for j in range(i * 2, size + 1, i):
			if array[i] < array[j]:
				count[j] = max(count[j], 1 + count[i])
	print(max(count))
testCases = int(input())
while testCases:
	N = int(input())
	A = [int(x) for x in input().split()]
	A = [-1] + A
	solve(N, A)
	testCases -= 1


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
lambda i: int(stdin.readline())
lambda inp: map(int, stdin.readline().split())
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	if n == 1:
		ans = 1
	else:
		dic = [1] * n
		for i in range(1, n + 1):
			ch = []
			for j in range(1, int(i ** 0.5) + 1):
				if i % j == 0:
					idx1 = j
					idx2 = i // j
					if arr[idx1 - 1] < arr[i - 1]:
						ch.append(dic[idx1 - 1])
					if arr[idx2 - 1] < arr[i - 1]:
						ch.append(dic[idx2 - 1])
			if len(ch) == 0:
				pass
			else:
				dic[i - 1] = max(ch) + 1
		ans = max(dic)
	print(ans)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j] > l[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


def solve():
	n = int(input())
	l = list(map(int, input().split()))
	f = [1] * (n + 1)
	l.insert(0, 0)
	n += 1
	for i in range(1, n // 2 + 1):
		for j in range(i * 2, n, i):
			if l[i] < l[j]:
				f[j] = max(f[j], f[i] + 1)
	print(max(f))
	return
T = int(input())
for _ in range(T):
	solve()


t = int(input())
while t:
	t = t - 1
	n = int(input())
	b = list(map(int, input().split()))
	a = [0]
	new = [i for i in b]
	a = a + new
	l = [1 for i in range(n + 1)]
	if n == 1:
		print(1)
		continue
	for i in range(n // 2 + 1, 0, -1):
		for j in range(i * 2, n + 1, i):
			if a[j] > a[i]:
				l[i] = max(l[i], l[j] + 1)
	print(max(l))


for i in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	ans = [1 for i in range(n)]
	for i in range(n):
		size = s[i]
		for j in range(i + 1, n + 1, i + 1):
			index = j - 1
			if s[index] > size:
				ans[index] = max(ans[index], ans[i] + 1)
	print(max(ans))


def abc(n):
	i = 2
	while True:
		if not n % i:
			return i
		i += 1
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l = [0] + l
	dp = [1] * (n + 1)
	for i in range(n, 0, -1):
		for j in range(2 * i, n + 1, i):
			if l[j] > l[i]:
				dp[i] = max(dp[i], 1 + dp[j])
	print(max(dp))


import math
t = int(input())
for T in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a = [0] + a
	dp = [0] + [0] * n
	ans = 0
	for i in range(n, 0, -1):
		maxi = 0
		for j in range(i + i, n + 1, i):
			if a[i] < a[j]:
				maxi = max(maxi, dp[j])
		dp[i] = 1 + maxi
		ans = max(ans, dp[i])
	print(ans)


for t in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	l = [1] * (n + 2)
	a.insert(0, 0)
	for i in range(2, n + 1):
		c = i
		z = int(c ** 0.5) + 1
		s = 0
		f = 1
		r = 0
		while f <= z:
			if f == z:
				break
			if i % f == 0 and a[i] > a[i // f]:
				r = max(r, l[i // f])
			if i % f == 0 and a[i] > a[f]:
				r = max(r, l[f])
			f += 1
		if r != 0:
			l[i] = r + 1
	print(max(l))


import sys
for t in range(int(sys.stdin.readline())):
	n = int(sys.stdin.readline())
	a = tuple(map(int, sys.stdin.readline().split()))
	dp = [1 for i in range(n)]
	for i in range(2, n + 1):
		sex = {0}
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0:
				q = i // j
				if a[i - 1] > a[j - 1]:
					sex.add(dp[j - 1])
				if j != q and a[i - 1] > a[q - 1]:
					sex.add(dp[q - 1])
		dp[i - 1] += max(sex)
	sys.stdout.write(f'{max(dp)}\n')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = I()
	rr = []
	for _ in range(t):
		n = I()
		a = LI()
		r = [1] * n
		for (i, t) in enumerate(a):
			k = r[i]
			j = i + 1
			for j in range(i * 2 + 1, n, i + 1):
				if t < a[j] and r[j] <= k:
					r[j] = k + 1
		rr.append(max(r))
	return JA(rr, '\n')
print(main())


def div(n):
	i = 2
	li = [1]
	while i * i <= n:
		if n % i == 0:
			li.append(i)
			li.append(n // i)
		i += 1
	return li
t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	fli = [1 for i in range(n + 1)]
	for j in range(2, n + 1):
		var = []
		for k in div(j):
			if arr[k - 1] < arr[j - 1]:
				var.append(fli[k] + 1)
		if len(var) > 0:
			fli[j] = max(var)
		else:
			fli[j] = 1
	print(max(fli))


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a = [-1] + a
	result = [-1] + [1] * n
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if a[i] < a[j]:
				result[j] = max(result[i] + 1, result[j])
	print(max(result))


def divisor(n):
	res = list()
	i = 1
	while i ** 2 <= n:
		if n % i == 0:
			res.append(i)
			if i ** 2 != n:
				res.append(n // i)
		i += 1
	res.sort()
	return res
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	dp = [-1] * (n + 1)
	ans = 0
	for i in range(n):
		dp[i] = 1
		div = divisor(i + 1)
		for j in div:
			if a[j - 1] < a[i]:
				dp[i] = max(dp[i], dp[j - 1] + 1)
		ans = max(ans, dp[i])
	print(ans)


for u in range(int(input())):
	n = int(input())
	l = [0] + list(map(int, input().split()))
	ka = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[i] < l[j]:
				ka[j] = max(ka[j], ka[i] + 1)
	print(max(ka))


def solve(n, ar):
	dp = [1] * (n + 1)
	dp[0] = -1
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if ar[i] < ar[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))
t = int(input())
for _ in range(t):
	n = int(input())
	ar = list(map(int, input().split()))
	ar.insert(0, -1)
	solve(n, ar)


t = int(input())
for tt in range(t):
	n = int(input())
	s = list(map(int, input().split(' ')))
	best_list = [-1] * n

	def best(i):
		global n
		global best_list
		if best_list[i - 1] != -1:
			return best_list[i - 1]
		k = 0
		if n % 2 == 0:
			k = round(n / 2)
		else:
			k = int(n / 2)
		if i > k:
			best_list[i - 1] = 1
			return 1
		else:
			ans = 1
			poss = []
			j = 2 * i
			while j <= n:
				if s[j - 1] > s[i - 1]:
					poss.append(best(j))
				j += i
				j = round(j)
			if len(poss) > 0:
				ans += max(poss)
			best_list[i - 1] = ans
			return ans
	for ii in range(1, n + 1):
		if best_list[ii - 1] == -1:
			best_list[ii - 1] = best(ii)
	print(max(best_list))


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	L = list(map(int, input().split()))
	g = [1] * n
	for i in range(n):
		j = 2 * i + 1
		while j < n:
			if L[j] > L[i]:
				g[j] = max(g[j], g[i] + 1)
			j += i + 1
	print(max(g))


import sys
import math

def comp():
	N = int(sys.stdin.readline())
	M = [0] + list(map(int, sys.stdin.readline().split()))
	dp = [1] * (N + 1)
	for i in range(1, N + 1):
		j = 1
		while j ** 2 <= i:
			if i % j != 0:
				j += 1
				continue
			if M[j] < M[i]:
				dp[i] = max(dp[i], dp[j] + 1)
			k = i // j
			if k not in [1, i, j] and M[k] < M[i]:
				dp[i] = max(dp[i], dp[k] + 1)
			j += 1
	print(max(dp))
T = int(sys.stdin.readline())
for i in range(T):
	comp()


import sys, bisect, string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby

def Golf():
	(*a,) = map(int, open(0))

def I():
	return int(input())

def S_():
	return input()

def IS():
	return input().split()

def LS():
	return [i for i in input().split()]

def LI():
	return [int(i) for i in input().split()]

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def GI(V, E, ls=None, Directed=False, index=1):
	org_inp = []
	g = [[] for i in range(V)]
	FromStdin = True if ls == None else False
	for i in range(E):
		if FromStdin:
			inp = LI()
			org_inp.append(inp)
		else:
			inp = ls[i]
		if len(inp) == 2:
			(a, b) = inp
			c = 1
		else:
			(a, b, c) = inp
		if index == 1:
			a -= 1
			b -= 1
		aa = (a, c)
		bb = (b, c)
		g[a].append(bb)
		if not Directed:
			g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, search=None, replacement_of_found='.', mp_def={'#': 1, '.': 0}, boundary=1):
	mp = [boundary] * (w + 2)
	found = {}
	for i in range(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def bit_combination(n, base=2):
	rt = []
	for tb in range(base ** n):
		s = [tb // base ** bt % base for bt in range(n)]
		rt += [s]
	return rt

def gcd(x, y):
	if x % y == 0:
		return y
	while x % y != 0:
		(x, y) = (y, x % y)
	return y

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
YN = ['YES', 'NO']
Yn = ['Yes', 'No']
mo = 10 ** 9 + 7
inf = float('inf')
FourNb = [(1, 0), (-1, 0), (0, 1), (0, -1)]
EightNb = [(1, 0), (-1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
compas = dict(zip('EWNS', FourNb))
l_alp = string.ascii_lowercase
input = lambda : sys.stdin.readline().rstrip()

class Tree:

	def __init__(self, inp_size=None, ls=None, init=True, index=0):
		self.LCA_init_stat = False
		self.ETtable = []
		if init:
			if ls == None:
				self.stdin(inp_size, index=index)
			else:
				self.size = len(ls) + 1
				(self.edges, _) = GI(self.size, self.size - 1, ls, index=index)
		return

	def stdin(self, inp_size=None, index=1):
		if inp_size == None:
			self.size = int(input())
		else:
			self.size = inp_size
		(self.edges, _) = GI(self.size, self.size - 1, index=index)
		return

	def listin(self, ls, index=0):
		self.size = len(ls) + 1
		(self.edges, _) = GI(self.size, self.size - 1, ls, index=index)
		return

	def __str__(self):
		return str(self.edges)

	def dfs(self, x, func=lambda prv, nx, dist: prv + dist, root_v=0):
		q = deque()
		q.append(x)
		v = [-1] * self.size
		v[x] = root_v
		while q:
			c = q.pop()
			for (nb, d) in self.edges[c]:
				if v[nb] == -1:
					q.append(nb)
					v[nb] = func(v[c], nb, d)
		return v

	def EulerTour(self, x):
		q = deque()
		q.append(x)
		self.depth = [None] * self.size
		self.depth[x] = 0
		self.ETtable = []
		self.ETdepth = []
		self.ETin = [-1] * self.size
		self.ETout = [-1] * self.size
		cnt = 0
		while q:
			c = q.pop()
			if c < 0:
				ce = ~c
			else:
				ce = c
				for (nb, d) in self.edges[ce]:
					if self.depth[nb] == None:
						q.append(~ce)
						q.append(nb)
						self.depth[nb] = self.depth[ce] + 1
			self.ETtable.append(ce)
			self.ETdepth.append(self.depth[ce])
			if self.ETin[ce] == -1:
				self.ETin[ce] = cnt
			else:
				self.ETout[ce] = cnt
			cnt += 1
		return

	def LCA_init(self, root):
		self.EulerTour(root)
		self.st = SparseTable(self.ETdepth, init_func=min, init_idl=inf)
		self.LCA_init_stat = True
		return

	def LCA(self, root, x, y):
		if self.LCA_init_stat == False:
			self.LCA_init(root)
		(xin, xout) = (self.ETin[x], self.ETout[x])
		(yin, yout) = (self.ETin[y], self.ETout[y])
		a = min(xin, yin)
		b = max(xout, yout, xin, yin)
		id_of_min_dep_in_et = self.st.query_id(a, b + 1)
		return self.ETtable[id_of_min_dep_in_et]

class SparseTable:

	def __init__(self, ls, init_func=min, init_idl=float('inf')):
		self.func = init_func
		self.idl = init_idl
		self.size = len(ls)
		self.N0 = self.size.bit_length()
		self.table = [ls[:]]
		self.index = [list(range(self.size))]
		self.lg = [0] * (self.size + 1)
		for i in range(2, self.size + 1):
			self.lg[i] = self.lg[i >> 1] + 1
		for i in range(self.N0):
			tmp = [self.func(self.table[i][j], self.table[i][min(j + (1 << i), self.size - 1)]) for j in range(self.size)]
			tmp_id = [self.index[i][j] if self.table[i][j] == self.func(self.table[i][j], self.table[i][min(j + (1 << i), self.size - 1)]) else self.index[i][min(j + (1 << i), self.size - 1)] for j in range(self.size)]
			self.table += [tmp]
			self.index += [tmp_id]

	def query(self, l, r):
		if r > self.size:
			r = self.size
		N = self.lg[r - l]
		return self.func(self.table[N][l], self.table[N][r - (1 << N)])

	def query_id(self, l, r):
		if r > self.size:
			r = self.size
		N = self.lg[r - l]
		(a, b) = (self.index[N][l], self.index[N][r - (1 << N)])
		if self.table[0][a] == self.func(self.table[N][l], self.table[N][r - (1 << N)]):
			b = a
		return b

	def __str__(self):
		return str(self.table[0])

	def print(self):
		for i in self.table:
			print(*i)

class Comb:

	def __init__(self, n, mo=10 ** 9 + 7):
		self.fac = [0] * (n + 1)
		self.inv = [1] * (n + 1)
		self.fac[0] = 1
		self.fact(n)
		for i in range(1, n + 1):
			self.fac[i] = i * self.fac[i - 1] % mo
			self.inv[n] *= i
			self.inv[n] %= mo
		self.inv[n] = pow(self.inv[n], mo - 2, mo)
		for i in range(1, n):
			self.inv[n - i] = self.inv[n - i + 1] * (n - i + 1) % mo
		return

	def fact(self, n):
		return self.fac[n]

	def invf(self, n):
		return self.inv[n]

	def comb(self, x, y):
		if y < 0 or y > x:
			return 0
		return self.fac[x] * self.inv[x - y] * self.inv[y] % mo
show_flg = False
show_flg = True
ans = 0
T = I()

def f(n):
	for i in range(2, int(n ** 0.5) + 10):
		if n % i == 0:
			return i
	return n
for _ in range(T):
	ans = 0
	n = I()
	s = [0] + LI()
	v = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2, n // i + 1):
			if s[i] < s[i * j]:
				v[i * j] = max(v[i] + 1, v[i * j])
	ans = max(v)
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	beauty = [1] * n
	for i in range(n):
		for j in range(2 * i + 1, n, i + 1):
			if s[j] > s[i]:
				beauty[j] = max(beauty[i] + 1, beauty[j])
	print(max(beauty))


from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
if os.path.exists('out.txt'):
	sys.stdout = open('out.txt', 'w')

def input():
	return sys.stdin.readline()

def mapi(arg=0):
	return map(int if arg == 0 else str, input().split())
sys.setrecursionlimit(10 ** 5)
from types import GeneratorType

def bootstrap(func, stack=[]):

	def wrapped_function(*args, **kwargs):
		if stack:
			return func(*args, **kwargs)
		else:
			call = func(*args, **kwargs)
			while True:
				if type(call) is GeneratorType:
					stack.append(call)
					call = next(call)
				else:
					stack.pop()
					if not stack:
						break
					call = stack[-1].send(call)
			return call
	return wrapped_function
for _ in range(int(input())):
	n = int(input())
	a = [0] + list(mapi())
	res = 0
	dp = [-1] * (n + 1)

	@bootstrap
	def rec(idx):
		if idx > n:
			return 0
		if idx == n:
			yield 1
		if dp[idx] != -1:
			yield dp[idx]
		ret = 1
		for i in range(2 * idx, n + 1, idx):
			if a[idx] < a[i]:
				ret = max(ret, (yield rec(i)) + 1)
		dp[idx] = ret
		yield ret
	for i in range(1, n + 1):
		res = max(res, rec(i))
	print(res)


from math import *
T = int(input())
for i in range(T):
	n = int(input())
	a = [0] + list(map(int, input().split()))
	f = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[i] < a[j]:
				f[j] = max(f[j], f[i] + 1)
	print(max(f))


n = int(input())
for _ in range(n):
	t = input()
	l = list(map(int, input().split(' ')))
	l.insert(0, -100)
	k = [1] * (len(l) + 1)
	for i in range(1, len(l)):
		j = 2 * i
		counter = 3
		while j < len(l):
			if l[j] > l[i]:
				k[j] = max(k[i] + 1, k[j])
			j = i * counter
			counter += 1
	print(max(k))


from collections import deque
t = int(input())
rez = []
for i in range(t):
	n = int(input())
	s = input().split()
	rezul = 1
	for j in range(n):
		s[j] = int(s[j])
	pres = []
	for j in range(n):
		pres.append(1)
	j = n // 2 - 1
	while j >= 0:
		pre = 0
		ind = j + j + 1
		while ind < n:
			if s[ind] > s[j]:
				if pres[ind] > pre:
					pre = pres[ind]
			ind += j + 1
		pres[j] += pre
		if pres[j] > rezul:
			rezul = pres[j]
		j -= 1
	rez.append(rezul)
for i in range(len(rez)):
	print(rez[i])


def main():
	import sys, math
	from heapq import heapify, heappush, heappop
	from collections import defaultdict as dd, deque, Counter

	def data():
		return sys.stdin.readline().strip()

	def mdata():
		return list(map(int, data().split()))

	def out(*var, end='\n'):
		sys.stdout.write(' '.join(map(str, var)) + end)
	INF = int(1000000000.0)
	mod = int(1000000000.0) + 7
	for t in range(int(data())):
		n = int(data())
		s = mdata()
		m = 1
		dp = [1] * (n + 1)
		for i in range(2, n + 1):
			for j in range(1, int(i ** 0.5) + 1):
				if i % j == 0:
					if s[i - 1] > s[j - 1]:
						dp[i] = max(dp[i], dp[j] + 1)
					if j != 1 and i // j != j and (s[i // j - 1] < s[i - 1]):
						dp[i] = max(dp[i], dp[i // j] + 1)
		print(max(dp))
main()


import math
testCases = int(input())
for _ in range(testCases):
	n = int(input())
	models = list(map(int, input().split()))
	answers = [1] * n
	for index in range(n):
		index_ = 2 * index + 1
		while index_ < n:
			if models[index_] > models[index]:
				answers[index_] = max(answers[index_], answers[index] + 1)
			index_ += index + 1
	print(max(answers))


import sys, math, cmath, time
start_time = time.time()
tt = 0

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	return input().strip()

def invr():
	return map(int, input().split())

def solve():
	n = inp()
	a = inlt()
	q = [0] * len(a)
	w = 0
	for i in range(len(a) // 2, -1, -1):
		qw = 0
		for j in range(2 * i + 1, n, i + 1):
			if a[j] > a[i]:
				qw = max(qw, q[j] + 1)
		q[i] = qw
		w = max(w, qw)
	print(w + 1)

def main():
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	t = inp()
	for tt in range(t):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
	sys.stdout.close()

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q

def string_counter(a):
	q = [0] * 26
	for i in range(len(a)):
		q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
	return q
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [1] * (n + 1)
	for i in range(1, n // 2 + 1):
		for j in range(2 * i, n + 1, i):
			if a[j - 1] > a[i - 1]:
				b[j] = max(b[j], b[i] + 1)
	print(max(b))


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

def solve():
	n = int(input())
	s = list(map(int, input().split()))
	ans = [0] * n
	for i in range(1, n + 1):
		ans[i - 1] = max(ans[i - 1], 1)
		for j in range(2 * i, n + 1, i):
			if s[i - 1] < s[j - 1]:
				ans[j - 1] = max(ans[j - 1], ans[i - 1] + 1)
	print(max(ans))
t = int(input())
for i in range(t):
	solve()


def solv():
	x = int(input())
	s = list(map(int, input().split()))
	dp = [1] * (x + 1)
	for n in range(1, x + 1):
		for k in range(2 * n, x + 1, n):
			if s[n - 1] < s[k - 1]:
				dp[k] = max(dp[k], dp[n] + 1)
	print(max(dp))
for _ in range(int(input())):
	solv()


def solve(size, data):
	log = [1] * size
	for i in range((size - 1) // 2, -1, -1):
		for j in range(2 * i + 1, size, i + 1):
			if data[i] < data[j]:
				log[i] = max(log[i], log[j] + 1)
	print(max(log))
counter = int(input())
for _ in range(counter):
	size = int(input())
	data = [int(i) for i in input().split()]
	solve(size, data)


import sys
import math
from collections import defaultdict

def solve(test):
	n = int(input())
	memo = [1] * (n + 1)
	s = list(map(int, input().split()))
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[j - 1] > s[i - 1]:
				memo[j] = max(memo[j], 1 + memo[i])
	print(max(memo))
test_cases = int(input())
for t in range(1, test_cases + 1):
	solve(t)


import math
num_cases = int(input())
for _ in range(num_cases):
	num_models = int(input())
	s = [None] + list(map(int, input().split()))
	memo = {}
	cur_index = 1
	max_start = int(num_models / 2)
	for idx in range(1, max_start + 1):
		multiple = 2
		vals = []
		while multiple * idx <= num_models:
			next_index = idx * multiple
			if s[next_index] > s[idx]:
				vals.append(next_index)
			multiple += 1
		if len(vals) > 0:
			memo[idx] = vals
	memo2 = {}

	def length_from_start(st):
		if st in memo2:
			return memo2[st]
		vals = memo.get(st)
		if vals is None:
			return 1
		resp = 1 + max(*map(length_from_start, vals), 1)
		memo2[st] = resp
		return resp
	max_val = 1
	for start in memo:
		max_val = max(max_val, length_from_start(start))
	print(max_val)


import math
import operator
T = int(input())
n = [0] * T
s = [0] * T
for t in range(T):
	n[t] = int(input())
	s[t] = [int(i) for i in input().split(' ')]

def divisors(n, s, F):
	divs = {}
	if n == 1:
		return 1
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divs[i - 1] = F[i - 1]
			divs[n // i - 1] = F[n // i - 1]
	return divs

def f(n, s, F):
	if n == 1:
		return 1
	else:
		d = sorted(divisors(n, s, F).items(), key=operator.itemgetter(1), reverse=True)
		for i in d:
			if s[i[0]] < s[n - 1]:
				F[n - 1] = F[i[0]] + 1
				break

def ans(n, s):
	best = 1
	F = [1] * n
	for i in range(1, n + 1):
		f(i, s, F)
	return max(F)
for t in range(T):
	print(ans(n[t], s[t]))


for t in range(int(input())):
	n = int(input())
	s = [None] + list(map(int, input().split()))
	answer = [0] * (n + 1)
	for i in range(n, 0, -1):
		if i > n / 2:
			answer[i] = 1
		else:
			multiplier = 2
			j = i
			m = 1
			while j * multiplier <= n:
				if s[j * multiplier] > s[j]:
					m = max(m, 1 + answer[j * multiplier])
				multiplier += 1
			answer[i] = m
	print(max(answer))


for _ in range(int(input())):
	n = int(input())
	(a, b, c, d, l, s) = (0, 1, 0, 0, [], [])
	lst = list(map(int, input().split()))
	ls = [1] * (n + 1)
	for i in range(1, n + 1):
		a = i * 2
		while a <= n:
			if lst[a - 1] > lst[i - 1]:
				ls[a] = max(ls[i] + 1, ls[a])
			a = a + i
	print(max(ls))


from math import ceil, sqrt

def find_dividers(n):
	answer = []
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			if i != n:
				answer.append(i)
			if i != ceil(sqrt(n)) and i != 1:
				answer.append(n // i)
	return answer

def din(values):
	answers = [1 for i in range(len(values))]
	ans = 1
	for i in range(1, len(values)):
		index = 1 + i
		dividers = find_dividers(index)
		for j in dividers:
			if values[j - 1] < values[i]:
				answers[i] = max(answers[i], answers[j - 1] + 1)
				ans = max(ans, answers[i])
	return ans

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		values = list(map(int, input().split()))
		print(din(values))
main()


def answer(n, s):
	f = [1] * (n + 1)
	s.insert(0, 0)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i] < s[j]:
				f[j] = max(f[j], f[i] + 1)
	return max(f)

def main():
	t = int(input())
	while t:
		n = int(input())
		s = [int(i) for i in input().split()]
		print(answer(n, s))
		t -= 1
	return
main()


for i in range(int(input())):
	n = int(input())
	num = list(map(int, input().split()))
	ans = n * [0]
	ansa = 0
	for i in range(n):
		z = 2
		ans[n - i - 1] = 1
		while (n - i) * z - 1 < n:
			if num[n - i - 1] < num[(n - i) * z - 1]:
				ans[n - i - 1] = max(ans[n - i - 1], 1 + ans[(n - i) * z - 1])
			z += 1
		ansa = max(ansa, ans[n - i - 1])
	print(ansa)


t = int(input())
for _ in range(t):
	n = int(input())
	S = list(map(int, input().split()))
	X = [1] * n
	for i in range(n):
		j = i + 1
		s = S[i]
		while j <= n:
			if S[j - 1] > s:
				X[j - 1] = max(X[i] + 1, X[j - 1])
			j += i + 1
	ans = -1
	for i in range(n):
		if X[i] >= ans:
			ans = X[i]
	print(ans)


from sys import *
from math import *
from bisect import *
t = int(stdin.readline())
for _ in range(t):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	b = [0] * n
	for i in range(n, 0, -1):
		for j in range(1, int(sqrt(i)) + 1):
			if i % j == 0:
				if a[i - 1] > a[j - 1]:
					b[j - 1] = max(b[i - 1] + 1, b[j - 1])
				k = i // j
				if a[i - 1] > a[k - 1]:
					b[k - 1] = max(b[i - 1] + 1, b[k - 1])
	print(max(b) + 1)


def dp(arr, i, j):
	if j <= n:
		if memo[j] == None:
			memo[j] = 1 + max((dp(arr, j, k * j) for k in range(2, n // j + 1)), default=0)
			if arr[j] > arr[i]:
				return memo[j]
			else:
				return 0
		elif arr[j] > arr[i]:
			return memo[j]
		else:
			return 0
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [None] + list(map(int, input().split()))
	memo = [None] + [None for i in range(n)]
	dp(arr, 1, 1)
	print(max(memo[1:]))


T = int(input())
for _ in range(0, T):
	n = int(input())
	s = [0] + [int(x) for x in input().split()]
	L = [1] * len(s)
	for i in range(1, len(L)):
		ptr = i + i
		while ptr <= n:
			if s[ptr] > s[i]:
				L[ptr] = max(L[ptr], L[i] + 1)
			ptr += i
	print(max(L))


from sys import stdin
from math import sqrt
input = stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = [1] + list(map(int, input().split()))
	v = [1] * (n + 1)
	for i in range(1, n // 2 + 2):
		for j in range(i * 2, n + 1, i):
			if a[i] < a[j]:
				v[j] = max(v[i] + 1, v[j])
	print(max(v))


for _ in range(int(input())):
	n = int(input())
	arr = [1 for _ in range(n + 1)]
	a = list(map(int, input().split()))
	for i in range(1, n // 2 + 1):
		if a[i] > a[0]:
			arr[i + 1] = max(arr[i + 1], 2)
		k = 2
		m = i + 1
		while m * k <= n:
			if a[m * k - 1] > a[m - 1]:
				arr[m * k] = max(arr[m * k], arr[m] + 1, int(a[m * k - 1] > a[0]) + 1)
			k += 1
	print(max(arr))


import math

def factors(num):
	ans = []
	maxi = int(math.sqrt(num)) + 1
	for i in range(1, maxi + 1):
		if num % i == 0:
			t1 = num // i
			if t1 == num or t1 == i:
				ans.append(i)
			else:
				ans.append(i)
				ans.append(t1)
	return ans
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(i) for i in input().split()]
	dp = [1] * n
	dp[0] = 1
	for i in range(1, n):
		x = factors(i + 1)
		for fact in x:
			if arr[fact - 1] < arr[i]:
				dp[i] = max(dp[i], dp[fact - 1] + 1)
	print(max(dp))


import sys
input = sys.stdin.readline

def long(N, A):
	dp = [1] * N
	s = 1
	for i in range(N):
		for j in range(i):
			if A[j] < A[i]:
				dp[i] = max(dp[i], dp[j] + 1)
	return max(dp)
for _ in range(int(input())):
	n = int(input())
	a = [0] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if a[i] < a[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest

def STR():
	return list(input())

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST():
	return list(map(int, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def sortListWithIndex(listOfTuples, idx):
	return sorted(listOfTuples, key=lambda x: x[idx])

def sortDictWithVal(passedDic):
	temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))[::-1]
	toret = {}
	for tup in temp:
		toret[tup[0]] = tup[1]
	return toret

def sortDictWithKey(passedDic):
	return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

def lds(arr, n):
	lds = [0 for i in range(n)]
	lds[0] = 1
	for i in range(n):
		lds[i] = 1
		for j in range(i):
			if lds[j] != 0 and arr[i] % arr[j] == 0:
				lds[i] = max(lds[i], lds[j] + 1)
	return max(lds)
t = INT()
while t != 0:
	n = INT()
	s = LIST()
	b = [1] * (n + 1)
	s.insert(0, 0)
	for i in range(n, 0, -1):
		for mult in range(2, n // i + 1):
			if s[i] < s[mult * i]:
				b[i] = max(b[i], b[mult * i] + 1)
			else:
				continue
	print(max(b))
	t -= 1


for s in [*open(0)][2::2]:
	a = (0, *map(int, s.split()))
	r = [1] * len(a)
	i = 0
	for x in a[1:]:
		i = j = i + 1
		for y in a[2 * i::i]:
			j += i
			r[j] = max(r[j], r[i] * (x < y) + 1)
	print(max(r))


def fun(arr, n):
	arr2 = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[j] > arr[i]:
				arr2[j] = max(arr2[j], arr2[i] + 1)
	return max(arr2)
t = int(input())
while t:
	n = int(input())
	arr = list(map(int, input().split()))
	arr.insert(0, 0)
	print(fun(arr, n))
	t -= 1


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	ans = 1
	flg = [False] * n
	q = []
	for i in range(1, n // 2 + 2):
		if flg[i - 1]:
			continue
		q = [(i, 1)]
		while q:
			(node, cnt) = q.pop()
			for c_node in range(2 * node, n + 1, node):
				if a[c_node - 1] <= a[node - 1]:
					continue
				flg[node - 1] = True
				if ans < cnt + 1:
					ans = cnt + 1
				q.append((c_node, cnt + 1))
	print(ans)


for _ in range(int(input())):
	n = int(input())
	arr = [0]
	arr = arr + list(map(int, input().split()))
	if n <= 1:
		print(n)
		continue
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[j] > arr[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


import math
t = int(input())
for tt in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1] * (n + 1)
	ans = -1
	for i in range(0, n):
		ans = max(ans, dp[i])
		for j in range(2 * (i + 1), n + 1, i + 1):
			if s[j - 1] <= s[i]:
				continue
			dp[j - 1] = max(dp[j - 1], dp[i] + 1)
	print(ans)


T = int(input())
for _ in range(T):
	N = int(input())
	S = list(map(int, input().split()))
	counts = [1] * N
	for i in range(N - 1, -1, -1):
		last = i
		j = 2 * i + 1
		for j in range(2 * i + 1, N, i + 1):
			if S[i] < S[j]:
				counts[i] = max(counts[i], counts[j] + 1)
	print(max(counts))


import math

def solve():
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(2, n + 1):
		for j in range(1, int(math.sqrt(i)) + 1):
			if i % j == 0:
				if s[i - 1] > s[j - 1]:
					dp[i] = max(dp[i], dp[j] + 1)
				t = i // j
				if t != j and s[i - 1] > s[t - 1]:
					dp[i] = max(dp[i], dp[t] + 1)
	ans = 1
	for i in range(1, n + 1):
		ans = max(ans, dp[i])
	print(ans)
for _ in range(int(input())):
	solve()


import math
t = int(input())
for tt in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	f = [1] * 100010
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[i - 1] < arr[j - 1]:
				f[j] = max(f[j], f[i] + 1)
	print(max(f))


import math
from functools import reduce

def all_factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
for _ in range(int(input())):
	n = int(input())
	s = [-1] + list(map(int, input().split()))
	m = [1] * (n + 1)
	for i in range(2, n + 1):
		x = 0
		for k in all_factors(i):
			if s[i] > s[k]:
				x = max(x, m[k])
		m[i] += x
	print(max(m))


t = int(input())
ans = []
for _ in range(t):
	N = int(input())
	S = list(map(int, input().split()))
	X = [1] * N
	for i in range(N):
		for j in range((i + 1) * 2 - 1, N, i + 1):
			if S[i] < S[j]:
				X[j] = max(X[j], X[i] + 1)
	ans.append(max(X))
for i in ans:
	print(i)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input().strip()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def from_file(f):
	return f.readline

def solve(n, s):
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[j - 1] > s[i - 1]:
				dp[j] = max(dp[j], 1 + dp[i])
	return max(dp)
t = inp()
for _ in range(t):
	n = inp()
	s = inlt()
	print(solve(n, s))


from math import sqrt
for T in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	l = [0] + s
	p = [1] * (n + 1)
	p[0] = 0
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[i] < l[j]:
				p[j] = max(p[j], p[i] + 1)
	print(max(p))


t = int(input())
for i in range(t):
	n = int(input())
	arre = list(map(int, input().split()))
	arr = [1 for j in range(n + 1)]
	for j in range(1, n + 1):
		arr[j] = arre[j - 1]
	f = [1 for j in range(n + 1)]
	for j in range(1, n + 1):
		p = j * 2
		for k in range(p, n + 1, j):
			if arr[j] < arr[k]:
				f[k] = max(f[k], f[j] + 1)
	ans = 0
	for j in range(1, n + 1):
		ans = max(ans, f[j])
	print(ans)


import sys
input = sys.stdin.buffer.readline
t = int(input())
for _ in range(t):
	n = int(input())
	s = [int(x) for x in input().split()]
	s.insert(0, -1)
	dp = [1 for __ in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if s[i] < s[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


from sys import stdin, stdout
from bisect import bisect_right as br
from bisect import bisect_left as bl
from bisect import insort_left as il
from math import gcd
inf = 10 ** 18
n = int(stdin.readline())
for i in range(n):
	k = int(stdin.readline())
	lst = [0]
	lst += [int(i) for i in stdin.readline().split()]
	dp = [1 for i in range(k + 1)]
	for j in range(1, k + 1):
		c = 1
		while j * c <= k:
			if lst[j * c] > lst[j]:
				dp[j * c] = max(dp[j * c], dp[j] + 1)
			c += 1
	stdout.write(str(max(dp)) + '\n')


t = int(input())

def divisors(n):
	ret = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			ret.append(i)
			if n // i == i:
				continue
			ret.append(n // i)
	ret.sort()
	return ret
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	arr = [1] * n
	ans = 1
	for i in range(n, 0, -1):
		div = divisors(i)
		S = s[i - 1]
		for x in div[:-1]:
			if s[x - 1] < S and arr[x - 1] < arr[i - 1] + 1:
				arr[x - 1] = arr[i - 1] + 1
	print(max(arr))


from sys import stdin
from math import gcd
inp = lambda : stdin.readline().strip()
t = int(inp())
for _ in range(t):
	n = int(inp())
	a = [int(x) for x in inp().split()]
	dp = [1] * n
	ans = 1
	for i in range(n - 2, -1, -1):
		counter = 2
		lastToCompare = a[i]
		maxDPI = dp[i]
		while True:
			if (i + 1) * counter > n:
				dp[i] = maxDPI
				break
			if a[i] < a[(i + 1) * counter - 1]:
				maxDPI = max(maxDPI, dp[i] + dp[(i + 1) * counter - 1])
			counter += 1
	print(max(dp))


import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda : readline().rstrip()
ni = lambda : int(readline().rstrip())
nm = lambda : map(int, readline().split())
nl = lambda : list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
	n = ni()
	s = nl()
	dp = [1] * (n + 1)
	for i in range(n // 2, 0, -1):
		for j in range(2 * i, n + 1, i):
			if s[i - 1] < s[j - 1]:
				dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))
	return
T = ni()
for _ in range(T):
	solve()


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007

def main():
	for t in range(I()):
		n = I()
		arr = [0] + L()
		ans = [1] * (n + 1)
		mx = 1
		for i in range(1, n + 1):
			j = 2 * i
			while j < n + 1:
				if arr[j] > arr[i]:
					ans[j] = max(ans[i] + 1, ans[j])
				j += i
		print(max(ans))
main()


from sys import stdin
import math
input = stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	dp = [1] * (n + 1)
	a.insert(0, 0)
	for x in range(1, n + 1):
		for y in range(x, n + 1, x):
			if a[x] < a[y]:
				dp[y] = max(dp[y], dp[x] + 1)
	print(max(dp))


def oracAndModels(n, array):
	dp = [0] * (n + 1)
	for x in reversed(range(n)):
		y = 2 * (x + 1) - 1
		mxVal = 0
		while y < n:
			if array[y] > array[x]:
				if dp[y] > mxVal:
					mxVal = dp[y]
			y += x + 1
		dp[x] = 1 + mxVal
	return max(dp)
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	print(oracAndModels(n, l))


from functools import lru_cache

@lru_cache(maxsize=None)
def find_factors(k):
	factors = []
	for i in range(1, int(k ** 0.5) + 1):
		if k % i == 0:
			factors.append(i)
			factors.append(k // i)
	return factors

def solve(lst):
	res = [1 for _ in lst]
	for (i, _) in enumerate(lst, start=1):
		for factor in find_factors(i):
			if lst[factor - 1] < lst[i - 1]:
				res[i - 1] = max(1 + res[factor - 1], res[i - 1])
	return max(res)
for _ in range(int(input())):
	_ = input()
	lst = list(map(int, input().split()))
	print(solve(lst))


import sys, os

def f():
	args = list(map(int, input().split()))
	return args
if 'local' in os.environ:
	sys.stdin = open('./input.txt', 'r')

def get_qsa(file_name):
	(audio, size) = readfile(file_name)
	headers = {'Connection': 'keep-alive', 'Content-Length': str(size)}
	parameter = {'request_id': int(time.time() * 100), 'th': 1, 'tht': 'qf492_100fps', 'the': 1.0, 'thst': 'neural'}
	res = requests.post(f"http://{config['ip']}:{config['port']}", timeout=120, data=audio, headers=headers, params=parameter)
	res_json = res.json()
	if res_json['retmsg'] != 'success':
		raise Exception
	bin_str = res_json['th'][0]['feat']
	bin_data = base64.b64decode(bin_str)
	bin2qsa_siren(bin_data, file_name)

def solve():
	t = f()[0]
	for _ in range(t):
		n = f()[0]
		s = f()
		s = [0] + s
		ans = [1] * (n + 1)
		res = 1
		for i in range(1, n + 1):
			for j in range(i + i, n + 1, i):
				if s[j] > s[i]:
					ans[j] = max(ans[j], ans[i] + 1)
					res = max(res, ans[j])
		print(res)
solve()


for i in range(int(input())):
	n = int(input())
	v = list(map(int, input().split()))
	mxarr = [1] * (n + 1)
	for i in range(n):
		for j in range(2 * i + 1, n, i + 1):
			if v[j] > v[i]:
				mxarr[j] = max(mxarr[j], mxarr[i] + 1)
	print(max(mxarr))


for __ in range(int(input())):
	n = int(input())
	lst = [int(i) for i in input().split()]
	pos = [1] * (n + 1)
	for i in range(1, n + 1):
		j = 2
		while i * j <= n:
			if lst[i - 1] < lst[i * j - 1]:
				pos[i * j] = max(pos[i * j], pos[i] + 1)
			j += 1
	print(max(pos))


import sys
tc = int(sys.stdin.readline())
for _ in range(tc):
	n = int(sys.stdin.readline())
	arr = [-1] + list(map(int, sys.stdin.readline().split()))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		j = 2 * i
		while j < n + 1:
			if arr[j] > arr[i]:
				dp[j] = max(dp[j], dp[i] + 1)
			j += i
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	v = [1] * (n + 1)
	a = list(map(int, input().split()))
	for i in range(1, n + 1):
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0:
				if j != 0:
					p = j
					q = i // j
					if a[p - 1] < a[i - 1]:
						v[i] = max(v[i], v[p] + 1)
					if a[q - 1] < a[i - 1]:
						v[i] = max(v[i], v[q] + 1)
				if a[j - 1] < a[i - 1]:
					v[i] = max(v[i], v[j] + 1)
	print(max(v))


def getMax(arr, count, n):
	maximum = 1
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			if i == n // i:
				if arr[i - 1] < arr[n - 1]:
					maximum = max(count[i - 1] + 1, maximum)
			else:
				if arr[i - 1] < arr[n - 1]:
					maximum = max(count[i - 1] + 1, maximum)
				if arr[n // i - 1] < arr[n - 1]:
					maximum = max(count[n // i - 1] + 1, maximum)
	return maximum
t = int(input())
while t != 0:
	n = int(input())
	arr = list(map(int, input().split()))
	count = []
	count.append(1)
	maximum = 1
	for i in range(1, n):
		count.append(0)
		count[i] = getMax(arr, count, i + 1)
		maximum = max(count[i], maximum)
	print(maximum)
	t = t - 1


import sys
input = sys.stdin.buffer.readline
T = int(input())
for testcase in range(T):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1] * n
	for i in range(n - 1, -1, -1):
		tmp = 1
		for j in range(2 * i + 1, n, i + 1):
			if tmp < dp[j] + 1 and s[i] < s[j]:
				tmp = dp[j] + 1
		dp[i] = tmp
	print(max(dp))


def get_max_for_idx(arr, idx):
	if type(arr[idx - 1]) is tuple:
		return arr[idx - 1][1]
	m = 2
	mx = 0
	x = arr[idx - 1]
	while idx * m <= len(arr):
		val = arr[idx * m - 1][0]
		if val > x:
			mx = max(mx, arr[idx * m - 1][1])
		m += 1
	return mx + 1
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	for i in reversed(range(n)):
		arr[i] = (arr[i], get_max_for_idx(arr, i + 1))
	print(max(map(lambda x: x[1], arr)))


def find(s, i):
	m_local = 0
	for j in range(2, (len(s) - 1) // i + 1):
		if s[i] < s[i * j]:
			m_local_new = find(s, i * j)
			if m_local_new > m_local:
				m_local = m_local_new
	return 1 + m_local

def solve():
	n = int(input())
	s = [0] + [int(x) for x in input().split()]
	m = 0
	for i in range(1, n + 1):
		m_new = find(s, i)
		if m_new > m:
			m = m_new
	print(m)
T = int(input())
for _ in range(T):
	solve()


import queue
import math
t = int(input())
while t:
	n = int(input())
	a = input().split()
	a = [0] + [int(x) for x in a]
	dp = [1 for i in range(n + 1)]
	ans = 1
	for i in range(n, 0, -1):
		for j in range(i + i, n + 1, i):
			if a[j] > a[i]:
				dp[i] = max(dp[i], 1 + dp[j])
		ans = max(ans, dp[i])
	print(ans)
	t -= 1


def to_list(s):
	return list(map(lambda x: int(x), s.split(' ')))

def solve(a):
	f = [1] * len(a)
	for i in range(len(a)):
		for j in range((i + 1) * 2, len(a) + 1, i + 1):
			if a[i] < a[j - 1]:
				f[j - 1] = max(f[j - 1], f[i] + 1)
	ans = 0
	for i in range(len(a)):
		ans = max(ans, f[i])
	return str(ans)
answers = []
t = int(input())
for i in range(t):
	n = int(input())
	a = to_list(input())
	answers.append(solve(a))
print('\n'.join(answers))


t = int(input())
for ci in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	mark = [0 for _ in range(n + 4)]
	for i in range(n - 1, -1, -1):
		nw = i + 1
		maxy = 0
		for j in range(i + nw, n, nw):
			if arr[j] > arr[i]:
				maxy = max(maxy, mark[j])
		mark[i] = maxy + 1
	print(max(mark))


import sys

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
import math

def factors(n):
	c = []
	for i in range(1, math.ceil(math.sqrt(n)) + 1):
		if n % i == 0:
			c.append(i)
			c.append(n // i)
	c.sort()
	return list(set(c))
maxi = -1
for _ in range(int(input())):
	n = int(input())
	a = get_array()
	if n == 1:
		print(1)
		continue
	dp = [1] * (n + 1)
	if a[1] > a[0]:
		dp[2] += 1
	for i in range(3, n + 1):
		x = factors(i)
		for j in range(len(x)):
			if x[j] != a[i - 1]:
				if a[i - 1] > a[x[j] - 1]:
					maxi = max(maxi, dp[x[j]])
		if maxi != -1:
			dp[i] = maxi + 1
		maxi = -1
	print(max(dp))


t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	max1 = float('-inf')
	array = {j + 1: l[j] for j in range(n)}
	tail = [0 for i in range(n + 1)]
	for j in range(2, n + 1):
		if array[1] < array[j]:
			tail[j] = max(tail[j], 1)
		temp = array[j]
		for k in range(2 * j, n + 1, j):
			if temp < array[k]:
				tail[k] = max(tail[j] + 1, tail[k])
	print(max(tail) + 1)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	dp = [1] * (n + 1)
	res = dp[0]
	for i in range(2, n + 1):
		c = 0
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0:
				a = i // j
				b = j
			if arr[a - 1] < arr[i - 1]:
				c = max(c, dp[a])
			if arr[b - 1] < arr[i - 1]:
				c = max(c, dp[b])
		dp[i] = dp[i] + c
		res = max(res, dp[i])
	print(res)


import math

def tc():
	n = int(input())
	sizes = [None] + [int(s) for s in input().split()]
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		j = i * 2
		while j <= n:
			if sizes[j] > sizes[i]:
				dp[j] = max(dp[j], dp[i] + 1)
			j += i
	return max(dp)
T = int(input())
for _ in range(T):
	ans = tc()
	print(ans)


import math

def printDivisors(n):
	arr = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				arr.append(i)
			else:
				arr.append(i)
				arr.append(n // i)
		i = i + 1
	arr.sort()
	return arr
t = int(input())
for test in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	dp = [1 for i in range(n + 1)]
	for i in range(2, n + 1):
		divarr = printDivisors(i)
		for j in range(len(divarr) - 1):
			if arr[divarr[j] - 1] < arr[i - 1]:
				dp[i] = max(dp[i], dp[divarr[j]] + 1)
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	l = [0] + [int(x) for x in input().split()]
	c = 1
	d = [1] * (n + 1)
	for i in range(1, n + 1):
		q = i * 2
		for j in range(q, n + 1, i):
			if l[j] > l[i]:
				d[j] = max(d[j], d[i] + 1)
	print(max(d))


counter = int(input())
for c in range(counter):
	size = int(input())
	data = list(map(int, input().split()))
	log = [1] * (size + 1)
	for i in range(1, size // 2 + 1):
		for j in range(i * 2, size + 1, i):
			if data[i - 1] < data[j - 1]:
				log[j] = max(log[j], log[i] + 1)
	print(max(log))


t = int(input())
for tt in range(t):
	n = int(input())
	s = input().split()
	dic = {}
	for i in range(n):
		s[i] = int(s[i])
		dic[i] = 0

	def foo(x):
		if dic[x] != 0:
			return dic[x]
		best = 1
		for j in range(x + x + 1, n, x + 1):
			if s[j] > s[x]:
				best = max(best, 1 + foo(j))
		dic[x] = best
		return best
	best = 1
	for i in range(n):
		for j in range(i + i + 1, n, i + 1):
			if s[j] > s[i]:
				best = max(best, 1 + foo(j))
	print(best)


t = int(input())
for i in range(t):
	n = int(input())
	a = [int(s) for s in input().split()]
	dp = [0] * n
	ans = 1
	for i in range(1, n + 1):
		dp[i - 1] += 1
		j = i + i
		while j <= n:
			if a[j - 1] > a[i - 1]:
				dp[j - 1] = max(dp[j - 1], dp[i - 1])
			j += i
		ans = max(ans, dp[i - 1])
	print(ans)


t = int(input())

def f1(start, n, a, mem):
	if mem[start] != 0:
		return mem[start]
	m = 1
	cur = start
	for j in range(2 * start, n + 1, cur):
		t = 0
		if a[j] > a[start]:
			t = f1(j, n, a, mem)
		t += 1
		if t > m:
			m = t
	mem[start] = m
	return mem[start]
for _ in range(t):
	n = int(input())
	a = [0]
	b = list(map(int, input().rstrip().split()))
	for i in b:
		a.append(i)
	mem = [0] * (n + 1)
	(ans, mx) = (0, 0)
	for i in range(1, n + 1):
		t = f1(i, n, a, mem)
		if t > ans:
			ans = t
	print(ans)


for _ in range(int(input())):
	n = int(input())
	l = [0] + list(map(int, input().split()))
	a = [1] * (n + 1)
	for i in range(n // 2, 0, -1):
		j = 2
		while i * j <= n:
			if a[j * i] + 1 > a[i] and l[i] < l[j * i]:
				a[i] = a[i * j] + 1
			j += 1
	print(max(a))


import sys
input = sys.stdin.readline
t_ = int(input())
while t_:
	t_ -= 1
	n = int(input())
	lis = [0] + list(map(int, input().split()))
	dp = [0] + [1] * n
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if lis[j] > lis[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


t = int(input())
while t != 0:
	t -= 1
	n = int(input())
	lt = [0] + [int(x) for x in input().split()]
	dp = [1] * (n + 1)
	for i in range(1, n // 2 + 1):
		for j in range(2 * i, n + 1, i):
			if lt[j] > lt[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


from sys import stdin, stdout
from math import gcd, ceil, sqrt
from collections import Counter
from bisect import bisect_left, bisect_right
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
tc = ii1()
for _ in range(tc):
	n = ii1()
	arr = [0] + iia()
	count = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i + i, n + 1, i):
			if arr[j] > arr[i] and count[i] >= count[j]:
				count[j] = count[i] + 1
	print(max(count))


t = int(input())
for tc in range(t):
	n = int(input())
	s = [0] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(n, 0, -1):
		for j in range(2, n + 2):
			if i * j > n:
				break
			elif s[i] < s[i * j]:
				dp[i] = max(dp[i], dp[i * j] + 1)
	print(max(dp))


from bisect import *
from collections import *
from math import gcd, ceil, sqrt, floor, inf
from heapq import *
from itertools import *
from functools import *
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
farr = [1]
ifa = []

def fact(x, mod=0):
	if mod:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr) % mod)
	else:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr))
	return farr[x]

def ifact(x, mod):
	global ifa
	fact(x, mod)
	ifa.append(pow(farr[-1], mod - 2, mod))
	for i in range(x, 0, -1):
		ifa.append(ifa[-1] * i % mod)
	ifa.reverse()

def per(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return fact(i) // fact(i - j)
	return farr[i] * ifa[i - j] % mod

def com(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return per(i, j) // fact(j)
	return per(i, j, mod) * ifa[j] % mod

def catalan(n):
	return com(2 * n, n) // (n + 1)

def isprime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def lowbit(n):
	return n & -n

def inverse(a, m):
	a %= m
	if a <= 1:
		return a
	return (1 - inverse(m, a) * m) // a % m

class BIT:

	def __init__(self, arr):
		self.arr = arr
		self.n = len(arr) - 1

	def update(self, x, v):
		while x <= self.n:
			self.arr[x] += v
			x += x & -x

	def query(self, x):
		ans = 0
		while x:
			ans += self.arr[x]
			x &= x - 1
		return ans

class DSU:

	def __init__(self, n):
		self.c = [-1] * n

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def find(self, x):
		if self.c[x] < 0:
			return x
		self.c[x] = self.find(self.c[x])
		return self.c[x]

	def union(self, u, v):
		(u, v) = (self.find(u), self.find(v))
		if u == v:
			return False
		if self.c[u] > self.c[v]:
			(u, v) = (v, u)
		self.c[u] += self.c[v]
		self.c[v] = u
		return True

	def size(self, x):
		return -self.c[self.find(x)]

class UFS:

	def __init__(self, n):
		self.parent = [i for i in range(n)]
		self.ranks = [0] * n

	def find(self, x):
		if x != self.parent[x]:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, u, v):
		(pu, pv) = (self.find(u), self.find(v))
		if pu == pv:
			return False
		if self.ranks[pu] >= self.ranks[pv]:
			self.parent[pv] = pu
			if self.ranks[pv] == self.ranks[pu]:
				self.ranks[pu] += 1
		else:
			self.parent[pu] = pv

def Prime(n):
	c = 0
	prime = []
	flag = [0] * (n + 1)
	for i in range(2, n + 1):
		if not flag[i]:
			prime.append(i)
			c += 1
		for j in range(c):
			if i * prime[j] > n:
				break
			flag[i * prime[j]] = prime[j]
			if i % prime[j] == 0:
				break
	return prime

def dij(s, graph):
	d = {}
	d[s] = 0
	heap = [(0, s)]
	seen = set()
	while heap:
		(dis, u) = heappop(heap)
		if u in seen:
			continue
		seen.add(u)
		for (v, w) in graph[u]:
			if v not in d or d[v] > d[u] + w:
				d[v] = d[u] + w
				heappush(heap, (d[v], v))
	return d

def GP(it):
	return [[ch, len(list(g))] for (ch, g) in groupby(it)]

class DLN:

	def __init__(self, val):
		self.val = val
		self.pre = None
		self.next = None

def nb(i, j):
	for (ni, nj) in [[i + 1, j], [i - 1, j], [i, j - 1], [i, j + 1]]:
		if 0 <= ni < n and 0 <= nj < m:
			yield (ni, nj)

@bootstrap
def gdfs(r, p):
	if len(g[r]) == 1 and p != -1:
		yield None
	for ch in g[r]:
		if ch != p:
			yield gdfs(ch, r)
	yield None
t = N()
for i in range(t):
	n = N()
	s = RLL()
	dp = [1] * n
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[j - 1] > s[i - 1]:
				dp[j - 1] = max(dp[i - 1] + 1, dp[j - 1])
	ans = max(dp)
	print(ans)


t = int(input())
for xx in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	lis = [1 for i in range(n)]
	for i in range(n):
		j = 2
		while j * (i + 1) <= n:
			if s[j * (i + 1) - 1] > s[i]:
				lis[j * (i + 1) - 1] = max(lis[j * (i + 1) - 1], lis[i] + 1)
			j += 1
	print(max(lis))


import math
t = int(input())
for hh in range(0, t):
	n = int(input())
	a = [int(x) for x in input().split()]
	a.insert(0, 0)
	dp = [1] * (n + 1)
	mx = 1
	for k in range(2, n + 1):
		i = 1
		while i <= math.sqrt(k):
			if k % i == 0:
				if k // i == i and a[k] > a[i]:
					dp[k] = max(dp[k], dp[i] + 1)
				else:
					if a[k] > a[i]:
						dp[k] = max(dp[k], dp[i] + 1)
					if a[k] > a[k // i]:
						dp[k] = max(dp[k], dp[k // i] + 1)
			i = i + 1
		mx = max(mx, dp[k])
	print(mx)


from math import *
t = int(input())
while t > 0:
	n = int(input())
	a = [int(x) for x in input().split()]
	ans = 1
	dp = []
	for i in range(n + 1):
		dp.append(1)
	for i in range(1, n + 1):
		m = 1
		for j in range(2 * i, n + 1, i):
			if a[i - 1] < a[j - 1]:
				dp[j] = max(dp[j], 1 + dp[i])
	print(max(dp))
	t -= 1


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import factorial, sqrt
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from bisect import bisect_left

def main():
	for _ in range(N()):
		n = N()
		arr = [0] + RLL()
		dp = [1] * (n + 1)
		res = 1
		for i in range(1, n + 1):
			for j in range(1, int(sqrt(i)) + 1):
				if i % j == 0 and j < i:
					if arr[i] > arr[j]:
						dp[i] = max(dp[i], dp[j] + 1)
					if arr[i // j] < arr[i]:
						dp[i] = max(dp[i], dp[i // j] + 1)
					res = max(res, dp[i])
		print(res)
main()


t = int(input())
a = []
n = 10 ** 5
a.append([0])
a.append([1])
n1 = 317
for i in range(2, n + 1):
	a.append([1])
for i in range(2, n1 + 1):
	for j in range(2 * i, n + 1, i):
		n3 = int(j / i)
		a[j].append(i)
		if n3 > n1 and n3 != j:
			a[j].append(n3)
for _ in range(t):
	n = int(input())
	a1 = [int(i) for i in input().split()]
	dp = []
	ma = 1
	for i in range(n):
		dp.append(1)
	for i in range(1, n):
		for j in a[i + 1]:
			if a1[j - 1] < a1[i]:
				dp[i] = max(dp[i], dp[j - 1] + 1)
		ma = max(ma, dp[i])
	print(ma)


import math

def ri():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def inp():
	return int(input())

def si():
	return input()

def pYes():
	print('YES')

def pNo():
	print('NO')

def plist(l):
	print(''.join(l))
t = int(input())
for t1 in range(t):
	n = inp()
	l = li()
	dp = [1] * (n + 1)
	ans = 1
	for i in range(1, n):
		r = i + 1
		q = 0
		for d in range(1, int(math.sqrt(r)) + 1):
			if r % d == 0:
				if l[r - 1] > l[d - 1]:
					q = max(q, dp[d])
				x = r // d
				if l[r - 1] > l[x - 1]:
					q = max(q, dp[x])
		dp[r] += q
		ans = max(ans, dp[r])
	print(ans)


t = int(input())
while t:
	t -= 1
	n = int(input())
	a = [int(x) for x in input().split()]
	m = [1 for x in range(n + 1)]
	a.insert(0, 0)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if a[i] < a[j]:
				m[j] = max(m[i] + 1, m[j])
	print(max(m))


import math

def divisorGenerator(n):
	divisors = []
	large_divisors = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			divisors.append(i)
			if i * i != n:
				divisors.append(int(n / i))
	divisors.remove(n)
	return divisors
nb_cases = int(input())
answer = []
while nb_cases > 0:
	nb_cases -= 1
	n = int(input())
	s = [0] + [int(x) for x in input().split()]
	dp = [0] * (n + 1)
	dp[0] = 0
	dp[1] = 1
	for x in range(2, n + 1):
		max_val = 1
		for y in divisorGenerator(x):
			if s[x] > s[y] and max_val < dp[y] + 1:
				max_val = dp[y] + 1
		dp[x] = max_val
	answer.append(max(dp))
for x in answer:
	print(x)


def solve(n, s):
	dp = [1] * n
	for i in range(n):
		for j in range(i + (i + 1), n, i + 1):
			if s[j] > s[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)
for i in range(int(input())):
	n = int(input())
	s = [int(x) for x in input().split()]
	print(solve(n, s))


MOD = 1000000000.0 + 7

class Solution:

	def solve(self, n, nums):
		dp = [1] * n
		for i in range(0, n):
			for j in range((i + 1) * 2, n + 1, i + 1):
				if nums[i] < nums[j - 1]:
					dp[j - 1] = max(dp[j - 1], dp[i] + 1)
		print(max(dp))
		return

def main():
	t = int(input())
	sol = Solution()
	while t:
		n = int(input())
		nums = list(map(int, input().strip().split()))
		sol.solve(n, nums)
		t -= 1
main()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	s = [None] + s
	lcs = [None] * n
	lcs = [0] + lcs
	lcs[n] = 1
	for i in range(n - 1, 0, -1):
		lcs[i] = max([lcs[i * j] + 1 for j in range(2, n // i + 1) if s[i * j] > s[i]] + [1])
	print(max(lcs))


import sys
input = sys.stdin.readline

def list_input():
	return list(map(int, input().split()))

def float_compare(a, b):
	if abs(a - b) < float(1e-09):
		return True
	else:
		return False

def sub_mod(x, mod):
	x = x % mod
	if x < 0:
		x += mod
	return x

def divisor(n):
	i = 1
	dv = []
	while i * i <= n:
		if n % i == 0:
			dv.append(i)
			if i * i != n:
				dv.append(n // i)
		i += 1
	return dv

def binpow(a, n):
	ans = 1
	while n:
		if n & 1:
			ans *= a
		a *= a
		n >>= 1
	return ans
for _ in range(int(input())):
	n = int(input().strip())
	l = list_input()
	l.insert(0, -1)
	ans = [1] * int(1000000.0)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if l[i] < l[j]:
				ans[j] = max(ans[j], ans[i] + 1)
	anss = 0
	for i in range(1, n + 1):
		anss = max(anss, ans[i])
	print(anss)


import sys
input = sys.stdin.buffer.readline
t = int(input())
ans = []
for _ in range(t):
	n = int(input())
	(*a,) = map(int, input().split())
	dp = [1] * (n + 1)
	dp[1] = 1
	for i in range(2, n + 1):
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0:
				if a[j - 1] < a[i - 1] and dp[j] + 1 > dp[i]:
					dp[i] = dp[j] + 1
				if j != 1:
					jj = i // j
					if a[jj - 1] < a[i - 1] and dp[jj] + 1 > dp[i]:
						dp[i] = dp[jj] + 1
	ans.append(max(dp))
print('\n'.join(map(str, ans)))


from math import sqrt

def div(n):
	res = []
	i = 1
	while i <= sqrt(n):
		if n % i == 0:
			if n // i == i:
				res.append(i)
			else:
				res.append(i)
				res.append(n // i)
		i += 1
	res.sort()
	res.pop()
	return res
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(2, n + 1):
		idx = div(i)
		for j in idx:
			if a[i] > a[j]:
				dp[i] = max(dp[j] + 1, dp[i])
		idx.clear()
	print(max(dp))


import sys
input = sys.stdin.buffer.readline
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(c) for c in input().split()]
	arr.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[j] > arr[i]:
				dp[j] = max(dp[j], 1 + dp[i])
	print(max(dp))


import math

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l
for i in range(int(input())):
	n = int(input())
	l1 = list(map(int, input().split()))
	dp = [1] * (len(l1) + 1)
	for j in range(1, len(l1) + 1):
		div = Divisors(j)
		for jj in div:
			if jj != j:
				if l1[jj - 1] < l1[j - 1]:
					if dp[j] < dp[jj] + 1:
						dp[j] = dp[jj] + 1
	print(max(dp))


t = int(input())
for q in range(t):
	n = int(input())
	ch = input()
	L = [0]
	for i in ch.split():
		L.append(int(i))
	dp = [1] * (n + 1)
	for i in range(1, n + 2):
		j = i
		while j < n + 1:
			if L[j] > L[i]:
				dp[j] = max(dp[i] + 1, dp[j])
			else:
				dp[j] = dp[j]
			j += i
	print(max(dp))


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1] * (n + 1)
	ans = 1
	for i in range(n // 2, 0, -1):
		k = 2
		while k * i <= n:
			if s[k * i - 1] > s[i - 1]:
				dp[i] = max(dp[k * i] + 1, dp[i])
			k += 1
	for i in range(1, n + 1):
		ans = max(dp[i], ans)
	print(ans)


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	ans = [1] * n
	for i in range(n):
		for j in range(i, n, i + 1):
			if a[j] > a[i]:
				ans[j] = max(ans[j], ans[i] + 1)
	fa = 0
	for i in range(n):
		fa = max(fa, ans[i])
	print(fa)


n = int(input())
import math

def divisors(n):
	divs = [1]
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			divs.extend([i, n // i])
	divs.extend([n])
	return list(set(divs))
for i in range(2 * n):
	if i % 2 == 0:
		k = int(input())
	if i % 2 == 1:
		l = list(map(int, input().split()))
		b = [1] * k
		for j in range(1, k + 1):
			h = divisors(j)
			for m in h:
				if j % m == 0 and l[j - 1] > l[m - 1] and (m != j):
					b[j - 1] = max(b[j - 1], b[m - 1] + 1)
		print(max(b))


for t in range(int(input())):
	n = int(input())
	l = [0] + list(map(int, input().split()))
	l1 = [1] * (n + 1)
	for i in range(n // 2, 0, -1):
		for j in range(2, n):
			if i * j <= n:
				if l1[j * i] + 1 > l1[i] and l[i] < l[j * i]:
					l1[i] = l1[i * j] + 1
			else:
				break
	print(max(l1))


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools, itertools, operator, bisect
from collections import deque, defaultdict, OrderedDict
import collections

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	for _ in range(ri()):
		n = ri()
		a = [1] + ria()
		dp = [1] * 100001
		ans = 1
		for i in range(2, n + 1):
			mx = 0
			for j in range(1, int(math.sqrt(i)) + 1):
				if i % j == 0:
					d1 = j
					d2 = i // j
					if a[d1] < a[i]:
						mx = max(mx, dp[d1])
					if a[d2] < a[i]:
						mx = max(mx, dp[d2])
			dp[i] += mx
			ans = max(ans, dp[i])
		print(ans)
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


from math import sqrt
for _ in range(int(input())):
	n = int(input())
	a = [0] + [int(i) for i in input().split()]
	dp = [0, 1]
	for i in range(2, n + 1):
		cur = 0
		dp.append(0)
		for j in range(1, int(sqrt(i)) + 1):
			if i % j == 0:
				if a[i] > a[j]:
					cur = max(cur, dp[j])
				if a[i] > a[i // j]:
					cur = max(cur, dp[i // j])
		dp[-1] = cur + 1
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l.insert(0, 0)
	res = [1] * (n + 1)
	for i in range(n // 2, 0, -1):
		j = 2
		while i * j <= n:
			if res[j * i] + 1 > res[i] and l[i] < l[j * i]:
				res[i] = res[j * i] + 1
			j += 1
	print(max(res))


import sys

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
	N = INT()
	A = LIST()
	dp = [1] * N
	for (i, a) in enumerate(A):
		j = i
		while j + i + 1 < N:
			if A[j + i + 1] > A[i]:
				dp[j + i + 1] = max(dp[j + i + 1], dp[i] + 1)
			j += i + 1
	ans = max(dp)
	print(ans)


from math import *
for zz in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	dp = [1] * (n + 1)
	for i in range(n - 1, 0, -1):
		j = 2 * i
		while j <= n:
			if a[i - 1] < a[j - 1]:
				dp[i] = max(dp[i], dp[j] + 1)
			j += i
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	x = list(map(int, input().split()))
	l = [0]
	for i in range(n):
		l.append(x[i])
	p = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(2, n + 1):
			if i * j > n:
				break
			elif l[i] < l[i * j]:
				p[i * j] = max(p[i * j], p[i] + 1)
	print(max(p))


import sys, string
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
t = I()
for _ in range(t):
	n = I()
	l = L()
	d = defaultdict(int)
	ans = 1
	for i in range(n - 1):
		if d[i] == 0:
			d[i] = 1
		j = 2
		while j * (i + 1) <= n:
			if l[i] < l[j * (i + 1) - 1] and d[j * (i + 1) - 1] < d[i] + 1:
				d[j * (i + 1) - 1] = d[i] + 1
				ans = max(ans, d[i] + 1)
			j += 1
	print(ans)


t = int(input())

def solve(n, arr):
	dp = [1 for _ in range(n + 1)]
	dp[0] = 0
	dp[1] = 1
	best = 1
	for i in range(1, n + 1):
		for k in range(i + i, n + 1, i):
			if arr[k - 1] > arr[i - 1]:
				dp[k] = max(dp[i] + 1, dp[k])
				best = max(dp[k], best)
	return best
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	print(solve(n, arr))


(T,) = map(int, input().split())
for t in range(T):
	(N,) = map(int, input().split())
	X = [0] + list(map(int, input().split()))
	dp = [1] * (N + 1)
	for i in range(1, N + 1):
		tmp = []
		for j in range(1, i):
			if i % j == 0:
				tmp.append(j)
				if j != i // j:
					tmp.append(i // j)
			if i < j * j:
				break
		for j in tmp:
			if X[j] < X[i]:
				dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))


import math
from sys import stdin, stdout
t = int(stdin.readline())
for _ in range(t):
	n = int(stdin.readline())
	l = list(map(int, stdin.readline().split()))
	a = [0 for i in range(n)]
	a[0] = 1
	for i in range(1, n):
		a[i] = 1
		x = math.sqrt(i + 1) + 1
		for j in range(1, int(x)):
			if (i + 1) % j == 0:
				if a[j - 1] != 0 and l[i] > l[j - 1]:
					a[i] = max(a[i], a[j - 1] + 1)
				if a[j - 1] != 0 and l[i] > l[(i + 1) // j - 1]:
					a[i] = max(a[i], a[(i + 1) // j - 1] + 1)
	print(max(a))


import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, stdin.readline().split()))
	temp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i + i, n + 1, i):
			if a[j - 1] > a[i - 1]:
				temp[j - 1] = max(temp[j - 1], temp[i - 1] + 1)
	print(max(temp))


def solve(n, s):
	dp = [1] * (n + 1)
	s = [0] + s
	i = 1
	while i <= n:
		j = 2
		while i * j <= n:
			if s[i * j] > s[i]:
				dp[i * j] = max(dp[i * j], dp[i] + 1)
			j += 1
		i += 1
	return max(dp)
for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	print(solve(n, s))


from __future__ import print_function
import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true = True
false = False
null = None
SLOW = True
try:
	range = xrange
except:
	ignored = 1

def fast():
	global SLOW
	SLOW = False

def compute(val, func):
	return func(val)

def seq(lo, hi, step=1):
	return range(lo, hi + 1, step)

def sround(val, nd):
	return '{0:.{1}f}'.format(val, nd)

def ceil(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans

def e1e(d, e):
	return d * 10 ** e
mod = e1e(1, 9) + 7
try:
	memoi = functools.lru_cache(None)
except:

	class memoize(dict):

		def __init__(self, f):
			self.f = f

		def __call__(self, *args):
			return self[args]

		def __missing__(self, key):
			ans = self[key] = self.f(*key)
			return ans
	memoi = memoize

class ndarray(list):

	def __init__(self, defval, sizes):
		self.sizes = sizes
		self.dimension = len(sizes)
		self.pm = pm = list(sizes)
		pm.append(1)
		for ii in reversed(range(self.dimension)):
			pm[ii] *= pm[ii + 1]
		list.__init__(self, [defval] * pm[0])

	def ___i1d___(self, ixs):
		if len(ixs) != self.dimension:
			raise LookupError('Dimension must be {}.'.format(self.dimension))
		ans = 0
		for ii in range(self.dimension):
			ix = ixs[ii]
			if ix >= self.sizes[ii]:
				raise IndexError('Index[{}]={} >= Len[{}]={}.'.format(ii, ix, ii, self.sizes[ii]))
			ans += ix * self.pm[ii + 1]
		return ans

	def __getitem__(self, ixs):
		ixs = self.___i1d___(ixs)
		return list.__getitem__(self, ixs)

	def __setitem__(self, ixs, val):
		ixs = self.___i1d___(ixs)
		list.__setitem__(self, ixs, val)

	def _str_(self, dim0=0, ofs=0):
		lft = '  ' * dim0
		if dim0 + 1 == self.dimension:
			return lft + str(list.__getitem__(self, slice(ofs, ofs + self.sizes[dim0])))
		ans = []
		for ii in range(self.sizes[dim0]):
			ans.append(self._str_(dim0 + 1, ofs))
			ofs += self.pm[dim0 + 1]
		ans = '{0}[\n{1}\n{0}]'.format(lft, ',\n'.join(ans))
		return ans

	def __str__(self):
		return self._str_()

def arrays(defval, *sizes):
	if len(sizes) == 1:
		return [defval] * sizes[0]
	return ndarray(defval, sizes)

def perr(*args, **kwargs):
	if SLOW:
		print(*args, file=sys.stderr, **kwargs)

def line():
	ln = sys.stdin.readline().strip()
	if ln == '':
		sys.exit()
	return ln

def lines(n):
	return [line() for i in range(n)]

def split(ln=None):
	return (ln or line()).split()

def num(str=None):
	str = str or line()
	return float(str) if '.' in str else int(str)

def nums(o=None):
	if o is not None:
		if isinstance(o, int):
			o = lines(o)
		elif isinstance(o, str):
			o = split(o)
	return list(map(num, o or split()))

def loop(f, n=0):
	for tcid in range(n or 99999999):
		f(tcid + 1)

def mainloop(tcid):
	ignored = 1
	n = num()
	s = nums()
	aa = arrays(1, n)
	for ii in seq(1, n):
		for jj in seq(ii + ii, n, ii):
			if s[ii - 1] < s[jj - 1]:
				aa[jj - 1] = max(aa[jj - 1], 1 + aa[ii - 1])
	print(max(aa))
tcmax = num()
loop(mainloop, tcmax)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = [0] + list(map(int, input().split()))
	dp = [0] + [1] * n
	for i in range(1, n):
		for m in range(2, n + 1):
			if i * m > n:
				break
			if a[i] < a[i * m]:
				dp[i * m] = max(dp[i * m], dp[i] + 1)
	print(max(dp))


def main(n, s):
	ans = 1
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		ans = max(ans, dp[i])
		for j in range(2, n + 1):
			nxt = i * j
			if nxt > n:
				break
			if s[i] >= s[nxt]:
				continue
			dp[nxt] = max(dp[nxt], dp[i] + 1)
	return ans
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	(*s,) = map(int, input().split())
	print(main(n, [0] + s))


import math
t = int(input())
for _ in range(t):
	n = int(input())
	l = [0] + list(map(int, input().split()))
	v = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j] > l[i]:
				v[j] = max(v[j], v[i] + 1)
	print(max(v))


t = int(input())
for i in range(t):
	n = int(input())
	crr = list(map(int, input().strip().split()))
	arr = []
	arr.append(0)
	for i in range(n):
		f = crr[i]
		arr.append(f)
	check = []
	for i in range(n + 1):
		check.append(0)
	for i in range(1, n + 1):
		check[i] = max(1, check[i])
		for j in range(i * 2, n + 1, i):
			if arr[i] < arr[j]:
				check[j] = max(check[j], check[i] + 1)
	ans = -1
	for i in range(n + 1):
		ans = max(ans, check[i])
	print(ans)


for _ in range(int(input())):
	n = int(input())
	data = list(map(int, input().split()))
	d = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if data[i - 1] < data[j - 1]:
				d[j] = max(d[j], d[i] + 1)
	print(max(d))


def factors(x):
	result = []
	i = 1
	while i * i <= x:
		if x % i == 0:
			result.append(i)
			if x // i != i:
				result.append(x // i)
		i += 1
	return result
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().strip().split()))
	dp = [1] * n
	for i in range(1, n + 1):
		x = factors(i)
		for j in x:
			if arr[j - 1] < arr[i - 1]:
				dp[i - 1] = max(dp[i - 1], dp[j - 1] + 1)
	print(max(dp))


import math

def getFactors(X):
	li = []
	for i in range(1, int(math.sqrt(X)) + 1):
		if X % i == 0:
			li.append(i)
			li.append(X // i)
	return li
for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(2, n + 1):
		fact = getFactors(i)
		maxm = 1
		for x in fact:
			if i % x == 0 and x < i and (s[i - 1] > s[x - 1]):
				maxm = max(maxm, dp[x] + 1)
		dp[i] = maxm
	print(max(dp))


from math import *
t = int(input())
for _ in range(t):
	n = int(input())
	size = list(map(int, input().split(' ')))
	f = [1 for _ in range(n + 1)]
	ans = 1
	for i in range(1, n + 1):
		for d in range(1, int(sqrt(i)) + 1):
			if i % d == 0:
				if size[i - 1] > size[d - 1]:
					f[i] = max(f[i], f[d] + 1)
				if size[i - 1] > size[i // d - 1]:
					f[i] = max(f[i], f[i // d] + 1)
			ans = max(ans, f[i])
	print(ans)


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split(' ')))
	store = []
	for i in range(0, n + 1):
		store.append(1)
	for i in range(1, n + 1):
		j = 2 * i
		while j <= n:
			if arr[i - 1] < arr[j - 1]:
				store[j] = max(store[j], store[i] + 1)
			j = j + i
	print(max(store))


for t in range(int(input())):
	n = int(input())
	l = [int(j) for j in input().split()]
	dp = [1 for i in range(n)]
	for i in range(n - 1, -1, -1):
		ls = [dp[j - 1] for j in range(i + 1, n + 1, i + 1) if l[j - 1] > l[i]]
		if ls:
			dp[i] += max(ls)
		dp[i] = max(dp[i], 1)
	print(max(dp))


def factors(n):
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			yield i
			if n // i != i:
				yield (n // i)
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	cs = [1] * n
	for i in range(n):
		for j in factors(i + 1):
			j -= 1
			if a[i] > a[j]:
				cs[i] = max(cs[i], cs[j] + 1)
	print(max(cs))


for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	d = [0] * (n + 1)
	for i in range(n):
		d[i + 1] = 1
	i = n
	while i >= 1:
		if 2 * i > n:
			i -= 1
			continue
		else:
			cur = 0
			j = 2 * i
			while j <= n:
				if s[i - 1] < s[j - 1]:
					cur = max(cur, d[j])
					d[i] = max(cur + 1, d[j])
				j += i
		i -= 1
	print(max(d))


for _ in range(int(input())):
	n = int(input())
	s = [0] + list(map(int, input().split()))
	kols = [1] * (n + 1)
	L = 1
	while L <= n:
		R = 2 * L
		while R <= n:
			if s[L] < s[R]:
				kols[R] = max(kols[R], kols[L] + 1)
			R += L
		L += 1
	print(max(kols))


from sys import stdin
import math
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	dp = [1] * (n + 1)
	res = 1
	a = [0] + list(map(int, stdin.readline().split()))
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if a[j] > a[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


t = int(input())
while t > 0:
	n = int(input())
	s = [int(ele) for ele in input().split()]
	dp = []
	for i in range(n):
		dp.append(1)
	for i in range(n):
		for j in range((i + 1) * 2 - 1, n, i + 1):
			if s[j] > s[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	maxi = -1
	for ele in dp:
		maxi = max(maxi, ele)
	print(maxi)
	t -= 1


def main() -> None:
	for _ in range(int(input())):
		n = int(input())
		A = [int(a) for a in input().split()]
		ans = 1
		dp = [1] * n
		for i in range(1, n + 1):
			for j in range(i * 2, n + 1, i):
				if A[j - 1] > A[i - 1]:
					dp[j - 1] = max(dp[j - 1], dp[i - 1] + 1)
		print(max(dp))
main()


import os
import sys
from io import BytesIO, IOBase
import math
from queue import Queue
import itertools
import bisect
import heapq

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n

def p2(n):
	c = 0
	while n % 2 == 0:
		n //= 2
		c += 1
	return c

def seive(n):
	primes = [True] * (n + 1)
	primes[1] = primes[0] = False
	for i in range(2, n + 1):
		if primes[i]:
			for j in range(i + i, n + 1, i):
				primes[j] = False
	p = []
	for i in range(0, n + 1):
		if primes[i]:
			p.append(i)
	return p

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def denofactinverse(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return pow(fac, m - 2, m)

def numofact(n, m):
	fac = 1
	for i in range(1, n + 1):
		fac = fac * i % m
	return fac

def sod(n):
	s = 0
	while n > 0:
		s += n % 10
		n //= 10
	return s
for xyz in range(0, int(input())):
	n = int(input())
	l = [10 ** 10] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j] > l[i]:
				dp[j] = max(dp[i] + 1, dp[j])
	print(max(dp))


t = int(input())
for _ in range(t):
	k = int(input())
	arr = [int(p) for p in input().split()]
	arr.insert(0, 0)
	cntr = [1] * (k + 1)
	for i in range(1, len(cntr)):
		j = 0
		while i * (1 + j) <= k:
			if arr[i * (1 + j)] > arr[i]:
				cntr[i * (1 + j)] = max(cntr[i * (1 + j)], cntr[i] + 1)
			j += 1
	print(max(cntr))


import math

def getFactors(n):
	res = []
	for i in range(1, int(math.sqrt(n)) + 1):
		if n % i == 0:
			res.append(i)
			if n // i != i:
				res.append(n // i)
	return res
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	res = [1] * n
	for i in range(n):
		ind = i + 1
		f = getFactors(ind)
		for j in f:
			if arr[i] > arr[j - 1]:
				res[i] = max(res[i], res[j - 1] + 1)
	r = max(res)
	if r == 0:
		print(1)
	else:
		print(r)


t = int(input())
for _ in range(0, t):
	n = int(input())
	s = [0] + [int(i) for i in input().split()]
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i] < s[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


def dividers(n):
	r = [1]
	i = 2
	while i * i <= n:
		if n % i == 0:
			r.append(i)
			k = n // i
			if k != i:
				r.append(k)
		i += 1
	return r
t = int(input())
itog = []
for _ in range(t):
	last = 1
	n = int(input())
	mass = list(map(int, input().split()))
	count = [1 for _ in range(n)]
	for i in range(1, n):
		x = dividers(i + 1)
		maxi = 1
		for j in x:
			if mass[j - 1] < mass[i]:
				if count[j - 1] >= maxi:
					maxi = count[j - 1] + 1
		count[i] = maxi
		if maxi > last:
			last = maxi
	itog.append(last)
for i in itog:
	print(i)


import random
import math
from collections import defaultdict
import itertools
from sys import stdin, stdout
import sys
import operator

def main():
	z = ''
	t = int(input())
	for _ in range(t):
		n = int(input())
		s = list(map(int, input().split()))
		dp = [0] * n
		for i in range(n, 0, -1):
			k = 1
			dp[i - 1] = 1
			while i * k <= n:
				if s[i * k - 1] > s[i - 1]:
					dp[i - 1] = max(dp[i - 1], dp[i * k - 1] + 1)
				k += 1
		print(max(dp))
main()


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys

def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i and i != 1:
				divisors.append(n // i)
	return divisors

def solve(n, S):
	DP = [1] * n
	for i in range(1, n + 1):
		D = make_divisors(i)
		for d in D:
			if S[d - 1] < S[i - 1]:
				DP[i - 1] = max(DP[i - 1], DP[d - 1] + 1)
	return max(DP)

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		S = tuple(map(int, input().split()))
		ans = solve(n, S)
		sys.stdout.write(str(ans) + '\n')
main()


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
from collections import *
for _ in range(ii()):
	n = ii()
	a = il()
	m = [1] * (n + 1)
	mx = 1
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j - 1] > a[i - 1] and m[i] + 1 > m[j]:
				m[j] = m[i] + 1
	for i in range(1, n + 1):
		mx = max(mx, m[i])
	print(mx)


t = int(input())
for i in range(t):
	n = int(input())
	models = list(map(int, input().split()))
	costs = [1] * n
	for divisor in range(1, n // 2 + 2):
		for division in range(divisor - 1, n, divisor):
			if models[division] > models[divisor - 1]:
				if costs[divisor - 1] + 1 > costs[division]:
					costs[division] = costs[divisor - 1] + 1
	print(max(costs))


import math

def divisors(n):
	divs = [1]
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			divs.extend([i, int(n / i)])
	divs.extend([n])
	return list(set(divs))
for ii in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	b = [1 for i in range(n)]
	for i in range(n):
		for j in divisors(i + 1):
			if a[j - 1] < a[i]:
				b[i] = max(1 + b[j - 1], b[i])
	print(max(b))


test = int(input())
for t in range(test):
	n = int(input())
	arr = input().split()
	table = [1 for i in range(n + 1)]
	for i in range(n):
		x = i + 1
		j = 2
		while x * j <= n:
			temp = x
			x *= j
			if int(arr[x - 1]) > int(arr[i]):
				table[x] = max(1 + table[i + 1], table[x])
			j += 1
			x = temp
	print(max(table))


import sys
input = sys.stdin.readline
T = int(input())
for _ in range(T):
	n = int(input())
	A = list(map(int, input().split()))
	B = [1 for i in range(n)]
	for i in range(n - 1, -1, -1):
		val = A[i]
		j = i + i + 2
		while j <= n:
			if A[j - 1] > val:
				B[i] = max(B[i], B[j - 1] + 1)
			j = j + i + 1
	print(max(B))


import math
t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	ans = [1] * n
	for i in range(n // 2 + 1):
		for j in range(2, n + 1):
			if j * (i + 1) > n:
				break
			if a[i] < a[j * (i + 1) - 1]:
				ans[j * (i + 1) - 1] = max(ans[j * (i + 1) - 1], ans[i] + 1)
	print(max(ans))


def f(a):
	res = set()
	for i in range(1, min(int(a ** 0.5) + 1, a)):
		if a % i == 0:
			res.add(i)
			res.add(a // i)
	return res
t = int(input())
cnt = 0
while cnt < t:
	cnt += 1
	n = int(input())
	a = list(map(int, input().split()))
	dp = [0] * n
	val = 1
	for i in range(n):
		dp[i] = 1
		res = f(i + 1)
		for elem in res:
			if a[i] > a[elem - 1]:
				dp[i] = max(dp[i], 1 + dp[elem - 1])
				if dp[i] > val:
					val = dp[i]
	print(val)


from collections import defaultdict as dc
from collections import Counter
from heapq import *
import math
from bisect import bisect_left, bisect
import sys
from collections import deque as dq
from heapq import heapify, heappush, heappop
mod = 10 ** 9 + 7

def sinp():
	p = str(input())
	return p

def seive(n):
	p = [0] * (n + 1)
	for i in range(2, n):
		if p[i] == 0:
			for j in range(2 * i, n + 1, i):
				p[i] = 1
	return p

def inp():
	p = int(input())
	return p

def line():
	p = list(map(int, input().split()))
	return p

def read_mat():
	n = inp()
	a = []
	for i in range(n):
		a.append(line())
	return a

def digit(n):
	s = str(n)
	p = 0
	for i in s:
		p += int(i) ** 2
	return p

def solve(a, n):
	p = [1] * (n + 1)
	for i in range(n, 0, -1):
		for z in range(1, int(i ** 0.5) + 1):
			if i % z == 0:
				if a[i - 1] > a[z - 1]:
					p[z] = max(p[z], p[i] + 1)
				if i != i // z and a[i - 1] > a[i // z - 1]:
					p[i // z] = max(p[i // z], p[i] + 1)
	return max(p)
for test in range(inp()):
	n = inp()
	a = line()
	l = solve(a, n)
	print(l)


def solve():
	int(input())
	arr = list(map(int, input().split(' ')))
	arr.insert(0, 0)
	dp = [1] * len(arr)
	for i in range(1, len(dp)):
		fac = 2
		while i * fac < len(dp):
			if arr[i * fac] > arr[i]:
				dp[i * fac] = max(dp[i * fac], dp[i] + 1)
			fac += 1
	print(max(dp))
T = int(input())
for i in range(T):
	solve()


def factors(n):
	arr = set([1])
	n_sqrt = int(n ** 0.5)
	for i in range(2, n_sqrt + 1):
		if n % i == 0:
			arr.add(i)
			arr.add(n // i)
	return arr
ans = []
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(i) for i in input().split()]
	dp = [1 for _ in range(n)]
	for i in range(1, n):
		x = 1
		for j in factors(i + 1):
			if a[j - 1] < a[i]:
				x = max(x, 1 + dp[j - 1])
		dp[i] = x
	ans.append(max(dp))
ans = '\n'.join([str(i) for i in ans])
print(ans)


import sys
import math
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	arr = list(map(int, sys.stdin.readline().split()))
	dp = [1 for x in range(n + 1)]
	for i in range(n - 1, 0, -1):
		j = i * 2
		cnt = 2
		cur = 1
		while j <= n:
			y = dp[j]
			if arr[j - 1] > arr[i - 1]:
				cur = max(cur, 1 + y)
			cnt += 1
			j = i * cnt
		dp[i] = cur
	ans = max(dp)
	print(ans)


import math
for _ in range(int(input())):
	n = int(input())
	seq = list(map(int, input().split()))
	leng = [1] * n
	globMax = 1
	for i in range(n - 1, -1, -1):
		mul = 2
		maxi = 0
		while (i + 1) * mul <= n:
			if seq[i] < seq[(i + 1) * mul - 1]:
				maxi = max(maxi, leng[(i + 1) * mul - 1])
			mul += 1
		leng[i] += maxi
		globMax = max(globMax, leng[i])
	print(globMax)


from sys import stdin

def solution2():
	input = stdin.readline
	t = int(input())
	for i in range(t):
		n = int(input())
		arr = [int(x) for x in input().split()]
		dp = [1] * n
		for i in range(1, n):
			for j in range(i * 2, n + 1, i):
				if arr[j - 1] > arr[i - 1]:
					dp[j - 1] = max(dp[i - 1] + 1, dp[j - 1])
		print(max(dp))
solution2()


cou = int(input())
for v in range(cou):
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	ans = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[i] < a[j]:
				ans[j] = max(ans[j], ans[i] + 1)
	print(max(ans))


t = int(input())
for _ in range(t):
	_ = int(input())
	A = [0] + list(map(int, input().split()))
	n = len(A)
	ans = 1
	dp = [1] * n
	for i in range(1, n):
		for j in range(i * 2, n, i):
			if A[j] > A[i]:
				dp[j] = max(dp[j], 1 + dp[i])
				ans = max(ans, dp[j])
	print(ans)


(z, zz) = (input, lambda : list(map(int, z().split())))
fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = int(z())
for _ in range(num):
	n = int(z())
	arr = [0] + zzz()
	ans = [0] + [1] * n
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[i] < arr[j]:
				ans[j] = max(ans[j], ans[i] + 1)
	print(max(ans))


for _ in range(int(input())):
	n = int(input()) + 1
	l = [0] + list(map(int, input().split()))
	visited = [1] * n
	for i in range(1, n):
		for j in range(i + i, n, i):
			if l[j] > l[i]:
				visited[j] = max(visited[j], visited[i] + 1)
	print(max(visited))


import math

def pd(n):
	l = []
	li = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				l.append(i)
			else:
				l.append(i)
				li.append(int(n / i))
	li.reverse()
	l.extend(li)
	return l

def lis(arr):
	n = len(arr)
	l = [1] * n
	for i in range(1, n):
		lis = pd(i + 1)
		lis.pop()
		for j in lis:
			if arr[i] > arr[j - 1] and l[i] < l[j - 1] + 1:
				l[i] = l[j - 1] + 1
	return max(l)
t = int(input())
for z in range(t):
	n = int(input())
	l = [int(i) for i in input().split()]
	print(lis(l))


def resolve():
	t = int(input())
	for _ in range(t):
		n = int(input())
		a = list(map(int, input().split()))
		print(getlength(a))

def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i and i != 1:
				divisors.append(n // i)
	return divisors

def getlength(L):
	res = 0
	N = len(L)
	dp = [1] * N
	for i in range(N):
		for j in make_divisors(i + 1):
			if L[j - 1] < L[i]:
				dp[i] = max(dp[i], dp[j - 1] + 1)
		res = max(res, dp[i])
	return res
resolve()


t = int(input())
d = dict()

def solve(ss, i):
	if i in d:
		return d[i]
	si = ss[i - 1]
	l = [1]
	i0 = i
	i += i0
	while i - 1 < len(ss):
		if ss[i - 1] > si:
			l.append(1 + solve(ss, i))
		i += i0
	result = max(l)
	d[i0] = result
	return d[i0]
for _ in range(t):
	d.clear()
	n = int(input())
	ss = list(map(int, input().split()))
	l = []
	for i in range(n):
		l.append(solve(ss, i + 1))
	print(max(l))


def solve(arr, n):
	memo = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if arr[i - 1] < arr[j - 1]:
				memo[j] = max(memo[j], memo[i] + 1)
	ans = 0
	for i in memo:
		if i > ans:
			ans = i
	return ans
tc = int(input())
for _ in range(tc):
	n = int(input())
	arr = list(map(int, input().split()))
	print(solve(arr, n))


from functools import lru_cache
for _ in range(int(input())):
	n = int(input())
	L = [0] + list(map(int, input().split()))

	@lru_cache(maxsize=None)
	def f(i):
		best = 1
		j = i * 2
		while j <= n:
			if L[j] > L[i]:
				best = max(best, 1 + f(j))
			j += i
		return best
	print(max((f(i) for i in range(1, n + 1))))


import sys

def div(i):
	d = []
	for j in range(1, i + 1):
		if j ** 2 > i:
			break
		if i % j == 0:
			d.append(j)
			if j ** 2 < i:
				d.append(i // j)
	return d

def solve():
	input = sys.stdin.readline
	T = int(input())
	Ans = [0] * T
	for i in range(T):
		N = int(input())
		A = [int(a) for a in input().split()]
		maxL = [0] * N
		ans = 0
		for j in reversed(range(N)):
			maxL[j] += 1
			ans = max(ans, maxL[j])
			d = div(j + 1)
			for divisor in d:
				if divisor != j + 1 and A[j] > A[divisor - 1]:
					maxL[divisor - 1] = max(maxL[divisor - 1], maxL[j])
		Ans[i] = ans
	print('\n'.join(map(str, Ans)))
	return 0
solve()


from math import *
t = int(input())
m = []
nn = []
for i in range(t):
	nn.append(int(input()))
	x = list(map(int, input().split()))
	m.append(x)
flag = -1
for i in range(t):
	n = nn[i]
	f = [1] * n
	x = m[i]
	for j in range(n):
		k = 1
		while (n - j) * k - 1 <= n - 1:
			if x[(n - j) * k - 1] > x[n - j - 1]:
				f[n - j - 1] = max(1 + f[(n - j) * k - 1], f[n - j - 1])
			k = k + 1
	print(max(f))


t = int(input())
for tt in range(t):
	n = int(input())
	s = [0]
	for i in input().split():
		s.append(int(i))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		f = 2
		cur = i * f
		while cur <= n:
			if s[cur] > s[i]:
				dp[cur] = max(dp[cur], dp[i] + 1)
			f += 1
			cur = i * f
	print(max(dp))


import math
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [1] * n
	for i in range(2, n + 1):
		for j in range(1, int(math.sqrt(i)) + 1):
			if i % j == 0:
				t = i // j
				if a[i - 1] > a[j - 1] and b[j - 1] + 1 > b[i - 1]:
					b[i - 1] = b[j - 1] + 1
				if a[i - 1] > a[t - 1] and b[t - 1] + 1 > b[i - 1]:
					b[i - 1] = b[t - 1] + 1
	print(max(b))


t = int(input())
for tc in range(t):
	n = int(input())
	l = [0]
	lis = list(map(int, input().split()))
	lis = l + lis
	ma = 0
	num = [1 for i in range(n + 1)]
	for k in range(n, 0, -1):
		j = k * 2
		lm = 1
		while j <= n:
			if lis[k] < lis[j]:
				if lm <= num[j] + num[k]:
					lm = num[j] + num[k]
			j += k
		num[k] = lm
		if num[k] >= ma:
			ma = num[k]
	print(ma)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	ans = [1] * n
	if n == 1:
		print(1)
		continue
	c = 1
	m = 1
	for i in range(n):
		ind = 2 * i + 1
		while ind < n:
			if l[ind] > l[i]:
				ans[ind] = max(ans[ind], ans[i] + 1)
			ind += i + 1
	print(max(ans))


from sys import stdin

def iinput():
	return int(stdin.readline())

def sinput():
	return input()

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
t = iinput()
while t:
	t -= 1
	n = iinput()
	s = linput()
	s.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i] < s[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	lis = list(map(int, input().split()))
	if lis == sorted(lis, reverse=True):
		print(1)
		continue
	lis.insert(0, 0)
	n += 1
	dp = [1] * n
	for i in range(1, n):
		for j in range(i + i, n, i):
			if lis[j] > lis[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


import sys
import math
from collections import deque
input = sys.stdin.buffer.readline
for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	if n == 1:
		print(1)
		continue
	count = [1] * n
	for i in range(1, n):
		for j in range(i * 2 - 1, n, i):
			if s[i - 1] < s[j]:
				count[j] = max(count[j], count[i - 1] + 1)
	print(max(count))


ans = [[] for i in range(100000)]
for i in range(1, 100000 + 1):
	for j in range(2 * i, 100000 + 1, i):
		ans[j - 1].append(i)
for i1 in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	tot = [1] * n
	for i in range(n):
		ma = 1
		for j in ans[i]:
			if l[j - 1] < l[i]:
				ma = tot[j - 1]
				ma += 1
			tot[i] = max(ma, tot[i])
	print(max(tot))


for _ in range(int(input())):
	n = int(input())
	lis = list(map(int, input().split()))
	dp = [1 for __ in range(n)]
	ans = 1
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if lis[j - 1] > lis[i - 1]:
				dp[j - 1] = max(dp[i - 1] + 1, dp[j - 1])
				ans = max(ans, dp[j - 1])
			else:
				pass
	print(ans)


t = int(input())
while t:
	t -= 1
	n = int(input())
	a = [0]
	a[1:] = list(map(int, input().strip().split(' ')))
	ans = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j] > a[i]:
				ans[j] = max(ans[j], ans[i] + 1)
	print(max(ans[1:]))


t = int(input())

def make_divisors(n: int):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	return sorted(divisors)
for i in range(t):
	N = int(input())
	S = list(map(int, input().split()))
	sorts = sorted([(v, i) for (i, v) in enumerate(S, start=1)])
	dp = [-1] * (N + 1)
	for j in range(N):
		idx = sorts[j][1]
		if idx == 1:
			dp[idx] = 1
			continue
		divisors = make_divisors(idx)
		dp[idx] = 1
		for d in divisors:
			if dp[d] == -1:
				continue
			if S[d - 1] == S[idx - 1]:
				continue
			dp[idx] = max(dp[idx], dp[d] + 1)
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	lis = [0] + list(map(int, input().split()))
	has = [1] * 100005
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if lis[i] < lis[j]:
				has[j] = max(has[j], has[i] + 1)
	print(max(has))


T = int(input())

def sort_model(elt):
	global models
	return models[elt - 1] * 1000000000 + elt

def sort_pos(elt):
	global pos
	return pos[elt - 1] * 1000000000 + elt

def get_score_from(x):
	global dpos
	global N
	global memo
	if x in memo:
		return memo[x]
	memo[x] = 1
	elts[x] = [models[x - 1]]
	if x * 2 > N or dpos[x - 1] == N:
		return 1
	m = 2
	while x * m <= N:
		if dpos[x * m - 1] > dpos[x - 1]:
			if 1 + memo[x * m] > memo[x] and (not models[x - 1] in elts[x * m]):
				memo[x] = 1 + memo[x * m]
				elts[x] = elts[x * m] + [models[x - 1]]
		m += 1
	return memo[x]
for _ in range(T):
	N = int(input())
	models = list(map(int, input().split()))
	pos = [i for i in range(1, N + 1)]
	pos.sort(key=sort_model)
	dpos = [i for i in range(1, N + 1)]
	dpos.sort(key=sort_pos)
	memo = {}
	elts = {}
	for elt in pos[::-1]:
		get_score_from(elt)
	ans = max(memo.values())
	print(ans)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = [1] * (n + 1)
	for i in range(n, -1, -1):
		maxi = 0
		for j in range(i + (i + 1), n, i + 1):
			if maxi < ans[j] and arr[i] < arr[j]:
				maxi = ans[j]
		ans[i] += maxi
	print(max(ans))


for _ in range(int(input())):
	n = int(input())
	lst = list(map(int, input().split()))
	lst2 = [1] * (n + 1)
	for i in range(n):
		j = 2 * i + 1
		while j < n:
			if lst[j] > lst[i]:
				lst2[j] = max(lst2[j], 1 + lst2[i])
			j += i + 1
	print(max(lst2))


t = int(input())

def dfs(x, visited, adj, dp):
	visited[x] = 1
	levels = [0]
	for node in adj[x]:
		if not visited[node]:
			levels.append(dfs(node, visited, adj, dp))
		else:
			levels.append(dp[node])
	dp[x] = max(levels) + 1
	return dp[x]
for _ in range(t):
	n = int(input())
	arr = [int(x) for x in input().split()]
	adj = {}
	for x in range(1, n + 1):
		adj[x] = []
		for y in range(x + x, n + 1, x):
			if arr[x - 1] < arr[y - 1]:
				adj[x].append(y)
	ans = 1
	visited = [0 for x in range(n + 1)]
	dp = {}
	for x in range(1, n + 1):
		if not visited[x]:
			dp[x] = dfs(x, visited, adj, dp)
	for k in dp:
		ans = max(dp[k], ans)
	print(ans)


for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	if n == 1:
		print(1)
		continue
	k = [0 for i in range(n)]
	ans = 0
	for i in range(int(n // 2), -1, -1):
		mx = 0
		for j in range(2 * (i + 1) - 1, n, i + 1):
			if s[j] > s[i]:
				mx = max(k[j] + 1, mx)
		k[i] = mx
		ans = max(ans, mx)
	print(ans + 1)


import sys
input = sys.stdin.readline

def find(i):
	if i >= n + 1:
		return 0
	ans = 1
	mx = 0
	if dp[i] != -1:
		return dp[i]
	for k in range(2, n + 1):
		if i * k > n:
			break
		if a[i] < a[i * k]:
			mx = max(mx, find(i * k))
	dp[i] = mx + ans
	return mx + ans
t = int(input())
for _ in range(0, t):
	n = int(input())
	a = list(map(int, input().split()))
	a = [0] + a
	dp = [-1] * (n + 2)
	ans = 1
	for i in range(1, n // 2 + 1):
		ans = max(ans, find(i))
	print(ans)


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		arr = list(map(int, input().strip().split()))
		dp = [1 for _ in range(n)]
		for i in range(1, n):
			num = i + 1
			j = 1
			while j * j <= num:
				if num % j == 0:
					if arr[j - 1] < arr[i]:
						dp[i] = max(dp[i], dp[j - 1] + 1)
					if arr[num // j - 1] < arr[i]:
						dp[i] = max(dp[i], dp[num // j - 1] + 1)
				j += 1
		print(max(dp))
main()


for _ in range(int(input())):
	n = int(input())
	S = [int(num) for num in input().split()]
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if S[i - 1] < S[j - 1]:
				dp[j] = max(dp[i] + 1, dp[j])
	print(max(dp))


import sys
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		N = int(input())
		S = [0] + [int(x) for x in input().split()]
		ans = 0
		aa = [0] * (N + 1)
		for i in range(N, -1, -1):
			ma = 0
			for j in range(2, N):
				if i * j > N:
					break
				if S[i * j] > S[i]:
					ma = max(ma, aa[i * j])
			aa[i] = ma + 1
		print(max(aa))
main()


t = int(input())
for _ in range(t):
	n = int(input())
	memo = [1 for _ in range(n + 1)]
	sizes = [-1] + [int(x) for x in input().split()]
	for i in range(1, n):
		for k in range(2, n // i + 1):
			if sizes[i] < sizes[i * k]:
				memo[i * k] = max(memo[i * k], memo[i] + 1)
	print(max(memo))


test = int(input())
for i in range(test):
	n = int(input())
	arr = [int(i) for i in input().split()]
	dp = [1] * n
	for i in range(len(arr) - 1, -1, -1):
		flag = 0
		intial = 2
		mul = (i + 1) * 2
		while mul <= len(arr):
			if arr[mul - 1] > arr[i]:
				dp[i] = max(dp[i], 1 + dp[mul - 1])
			intial += 1
			mul = (i + 1) * intial
	print(max(dp))


def checker(n, lst):
	b = [1] * n
	for i in range((n - 1) // 2, -1, -1):
		for j in range(2 * i + 1, n, i + 1):
			if lst[j] > lst[i] and b[i] < b[j] + 1:
				b[i] = b[j] + 1
	return max(b)
for _ in range(int(input())):
	m = int(input())
	a = [int(i) for i in input().split()]
	print(checker(m, a))


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	dp = [1] * (n + 1)
	i = n
	mx = 1
	while i > 0:
		j = i * 2
		while j <= n:
			if l[j - 1] > l[i - 1]:
				dp[i] = max(dp[i], dp[j] + 1)
				mx = max(mx, dp[i])
			j += i
		i -= 1
	print(mx)


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop
import math
from collections import *
from functools import reduce, cmp_to_key, lru_cache
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
M = mod = 10 ** 9 + 7

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip().split()]

def st():
	return str(input().rstrip())[2:-1]

def val():
	return int(input().rstrip())

def li2():
	return [str(i)[2:-1] for i in input().rstrip().split()]

def li3():
	return [int(str(i)[2:-1]) for i in input().rstrip()]
for _ in range(val()):
	n = val()
	l = [0] * (n + 1)
	minimum = [0] * n
	ans = [1] * (n + 1)
	an = 0
	l = li()
	l = [0] + l[:]
	for i in range(1, n + 1, 1):
		(c, x, t) = (1, i, 0)
		if l[i] > l[1]:
			t = ans[1]
		for j in range(2, int(x ** 0.5) + 1):
			if not x % j:
				if l[i] > l[j]:
					t = max(t, ans[j])
				if l[i] > l[x // j]:
					t = max(t, ans[x // j])
		c += t
		ans[x] = max(ans[x], c)
	print(max(ans[1:]))


import io
import os
from collections import Counter, defaultdict, deque

def solve(N, S):
	longest = [0 for i in range(N + 1)]
	for i in range(1, N + 1):
		longest[i] += 1
		m = 2
		while i * m <= N:
			if S[i - 1] < S[i * m - 1]:
				assert i < i * m
				longest[i * m] = max(longest[i * m], longest[i])
			m += 1
	return max(longest)
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	(N,) = [int(x) for x in input().split()]
	S = [int(x) for x in input().split()]
	ans = solve(N, S)
	print(ans)


def solve(nums):
	n = len(nums)
	ans = [1] * n
	for i in range(n):
		for j in range(min(int(i ** 0.5) + 1, i)):
			if (i + 1) % (j + 1) == 0:
				if nums[i] > nums[j]:
					ans[i] = max(ans[i], ans[j] + 1)
				if (i + 1) // (j + 1) != j + 1 and nums[i] > nums[(i + 1) // (j + 1) - 1]:
					ans[i] = max(ans[i], ans[(i + 1) // (j + 1) - 1] + 1)
	return max(ans)
t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	print(solve(arr))


f = [0] * 100005
T = int(input())
while T != 0:
	T -= 1
	n = int(input())
	a = [0] + list(map(int, input().split()))
	for i in range(1, n + 1):
		f[i] = 1
	ans = 0
	for i in range(1, n + 1):
		for j in range(i + i, n + 1, i):
			if a[i] < a[j]:
				f[j] = max(f[j], f[i] + 1)
		ans = max(ans, f[i])
	print(ans)


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))
ilelec = lambda : map(int1, input().split())
alelec = lambda : list(map(int1, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])
for _ in range(int(input())):
	n = int(input())
	A = alele()
	dp = [1] * n
	ans = 1
	for i in range(n // 2 + 1):
		for j in range(i, n, i + 1):
			if A[j] > A[i]:
				dp[j] = max(dp[i] + 1, dp[j])
				ans = max(ans, dp[j])
	print(ans)


from sys import stdin, stdout
cin = stdin.readline
cout = stdout.write
for _ in range(int(cin())):
	n = int(cin())
	s = (0, *map(int, cin().split()))
	a = [1] * (n + 1)
	for i in range(1, n + 1):
		j = i + i
		while j <= n:
			f = s[j] > s[i]
			a[j] = max(a[j], a[i] + 1) * f + (1 - f) * a[j]
			j += i
	cout(str(max(a)) + '\n')


flag_1 = int(input())
for f in range(0, flag_1):
	n = int(input())
	a = list(map(int, input().split()))
	dp = n * [0]
	answer = 0
	for i in range(0, n):
		u = 2
		dp[n - i - 1] = 1
		while (n - i) * u - 1 < n:
			if a[n - i - 1] < a[(n - i) * u - 1]:
				dp[n - i - 1] = max(dp[n - i - 1], 1 + dp[(n - i) * u - 1])
			u += 1
		answer = max(answer, dp[n - i - 1])
	print(answer)


for t in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	b = [1] * n
	for i in range((n - 1) // 2, -1, -1):
		for j in range(2 * i + 1, n, i + 1):
			if s[j] > s[i] and b[i] < b[j] + 1:
				b[i] = b[j] + 1
	print(max(b))


import sys
import math as mt
input = sys.stdin.buffer.readline
import bisect
t = int(input())
for __ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l.insert(0, 0)
	ch = [1] * (n + 1)
	for i in range(n // 2, 0, -1):
		j = 2
		k = i
		maxi = 0
		while k * j <= n:
			if l[i] < l[k * j]:
				maxi = max(maxi, ch[k * j])
			j += 1
		ch[i] += maxi
	print(max(ch[:]))


from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 9)
readline = stdin.readline
t = int(readline())
res = []
for _ in range(t):
	n = int(readline())
	s = list(map(int, readline().split()))
	flags = [0] * (n + 1)
	ans = 0

	def dfs(i, now):
		global ans
		global score
		if flags[i] != 0:
			ans = max(ans, now + flags[i] - 1)
			score = max(score, now + flags[i] - 1)
			return
		else:
			j = 2
			js = []
			while i * j <= n:
				js.append(j)
				j += 1
			for k in js:
				if s[i - 1] < s[i * k - 1]:
					dfs(i * k, now + 1)
			ans = max(ans, now)
			score = max(score, now)
	for i in range(n, 0, -1):
		score = 1
		dfs(i, 1)
		flags[i] = score
	res.append(ans)
for i in range(t):
	print(res[i])


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	a = [0] + list(map(int, stdin.readline().split()))
	dp = [1] * (1 + n)
	for ind in range(2, 1 + n):
		p = 1
		while p * p <= ind:
			if ind % p == 0:
				fact1 = ind // p
				fact2 = ind // fact1
				if a[ind] > a[fact1]:
					dp[ind] = max(dp[ind], dp[fact1] + 1)
				if a[ind] > a[fact2]:
					dp[ind] = max(dp[ind], dp[fact2] + 1)
			p += 1
	print(max(dp))


import sys
from math import gcd
for _ in range(int(input())):
	n = int(input())
	a = [0] + [int(x) for x in input().split()]
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if a[i] < a[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


from collections import Counter
import itertools
from functools import lru_cache
import sys
import math

def helper():
	pass

def solve():
	n = int(input())
	nodes = list(map(int, input().split(' ')))
	nodes = [0] + nodes
	adj = [[] for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if nodes[j] > nodes[i]:
				adj[i].append(j)
	visited = set()
	height = {}

	def dfs(node):
		visited.add(node)
		ans = 1
		for child in adj[node]:
			if child not in visited:
				ans = max(ans, 1 + dfs(child))
			else:
				ans = max(ans, 1 + height[child])
		height[node] = ans
		return height[node]
	ans = 0
	for node in range(1, n + 1):
		if node not in visited:
			ans = max(ans, dfs(node))
		else:
			ans = max(ans, height[node])
	print(ans)
t = int(input())
for _ in range(t):
	solve()


import sys
input = lambda : sys.stdin.readline().rstrip()
t = int(input())
for _ in range(t):
	n = int(input())
	S = [int(i) for i in input().split()]
	A = [1] * (n + 1)
	for i in range(1, n + 1):
		mul = 2
		while i * mul <= n:
			if S[i * mul - 1] > S[i - 1]:
				A[i * mul] = max(A[i * mul], A[i] + 1)
			mul += 1
	print(max(A))


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = list()
	for (i, j) in enumerate(a):
		b.append((i + 1, j))
	b.sort(key=lambda x: x[1])
	d = dict()
	for ii in range(n - 1, -1, -1):
		i = b[ii][0]
		j = 2
		d[i] = 1
		while i * j <= n:
			if a[i * j - 1] > a[i - 1]:
				d[i] = max(d.get(i * j, -1) + 1, d[i])
			j += 1
	print(max(d.values()))


def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(2, n):
		for j in range(1, i):
			if i % j == 0 and arr[i] > arr[j] and (lis[i] < lis[j] + 1):
				lis[i] = lis[j] + 1
	maximum = 0
	maximum = max(maximum, max(lis))
	return maximum
for t in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	s.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i + i, n + 1, i):
			if s[i] < s[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
import random
from queue import PriorityQueue
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p
import sys
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j - 1] > l[i - 1]:
				dp[j] = max(dp[i] + 1, dp[j])
	print(max(dp))


import math
res = []
vis = []

def findlength(a):
	if vis[a] == True:
		return res[a]
	vis[a] = True
	i = 2
	maximum = 1
	while i <= int(math.sqrt(a)):
		if a % i == 0 and s[int(a / i)] < s[a]:
			maximum = max(maximum, 1 + findlength(int(a / i)))
		if a % i == 0 and s[i] < s[a]:
			maximum = max(maximum, 1 + findlength(int(i)))
		i = i + 1
	if s[1] < s[a]:
		maximum = max(maximum, 2)
	res[a] = maximum
	return maximum
t = int(input())
while t > 0:
	t = t - 1
	n = int(input())
	inp = input().split()
	s = [0]
	res = [0]
	vis = [False]
	for i in range(n):
		s.append(int(inp[i]))
		res.append(1)
		vis.append(False)
	i = n
	for i in range(1, n):
		p = 2
		j = i * p
		while j <= n:
			if s[i] < s[j]:
				res[j] = max(res[j], 1 + res[i])
			p = p + 1
			j = i * p
	print(max(res))


from sys import stdin, stdout

def ai():
	return list(map(int, input().split()))

def ei():
	return map(int, input().split())

def ip():
	return int(stdin.readline())

def op(ans):
	return stdout.write(str(ans) + '\n')
t = ip()
while t:
	t -= 1
	n = ip()
	arr = ai()
	arr = [0] + arr
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if arr[i] < arr[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	op(max(dp))


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().strip().split()))
	dp = [1] * (n + 1)
	for i in range(1, (n + 1) // 2):
		j = 2
		while i * j <= n:
			if a[i * j - 1] > a[i - 1] and dp[i] + 1 > dp[i * j]:
				dp[i * j] = dp[i] + 1
			j += 1
	print(max(dp))


from math import gcd, ceil
from collections import defaultdict as dd

def lcm(a, b):
	return a * b // gcd(a, b)

def inin():
	return int(input())

def inar():
	return list(map(int, input().split()))

def ar(element, size):
	return [element for i in range(size)]

def digitsum(num):
	su = 0
	while num:
		su += num % 10
		num //= 10
	return su

def pred(n, k, pointer):
	return pointer - k >= n

def yes():
	print('YES')

def no():
	print('NO')
Testcase = inin()
for _ in range(Testcase):
	n = inin()
	s = [0] + inar()
	dp = [1 for f in range(n + 7)]
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if s[i] < s[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	dp = [1 for FUC in range(n + 1)]
	dp[0] = 0
	for j in range(2, n + 1):
		for k in range(1, int(j ** 0.5) + 1):
			if j % k == 0:
				if dp[j] < dp[k] + 1 and a[j - 1] > a[k - 1]:
					dp[j] = dp[k] + 1
				if k != 1 and dp[j] < dp[j // k] + 1 and (a[j - 1] > a[j // k - 1]):
					dp[j] = dp[j // k] + 1
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().strip().split(' ')))
	if n == 1:
		print(1)
		continue
	dp = [1 for i in range(1, n + 2)]
	dp[0] = 1
	for i in range(1, n + 1):
		for j in range(2, n + 1):
			xx = j * i - 1
			yy = i - 1
			if i * j > n:
				break
			if arr[xx] > arr[yy]:
				dp[xx] = max(dp[xx], dp[yy] + 1)
	print(max(dp))


def dp(i):
	i += 1
	if n // i < 2:
		return 1
	elif visited[i - 1]:
		return dparr[i - 1]
	else:
		k = 2
		xarr = [0]
		while k * i <= n:
			if arr[k * i - 1] > arr[i - 1]:
				xarr += [dp(k * i - 1)]
				tested[k * i - 1] = 0
			k += 1
		visited[i - 1] = 1
		dparr[i - 1] = 1 + max(xarr)
		return dparr[i - 1]
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	visited = [0] * n
	tested = [1] * n
	dparr = [1] * n
	darr = []
	for i in range(n):
		if tested[i]:
			darr += [dp(i)]
	print(max(darr))


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(1, int((i + 10) ** 0.5) + 1):
			if i % j == 0:
				if a[i - 1] > a[j - 1]:
					dp[i] = max(dp[i], dp[j] + 1)
				if a[i - 1] > a[i // j - 1]:
					dp[i] = max(dp[i], dp[i // j] + 1)
	print(max(dp))


for i in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	dp = [1 for i in range(n)]
	for i in range(1, n):
		for j in range(i - 1, n, i):
			if a[j] > a[i - 1]:
				dp[j] = max(dp[j], 1 + dp[i - 1])
	ans = 1
	for i in dp:
		ans = max(ans, i)
	print(ans)


import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt, floor, factorial, gcd, log, ceil
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations

def Int():
	return int(sys.stdin.readline())

def Mint():
	return map(int, sys.stdin.readline().split())

def Lstr():
	return list(sys.stdin.readline().strip())

def Str():
	return sys.stdin.readline().strip()

def Mstr():
	return map(str, sys.stdin.readline().strip().split())

def List():
	return list(map(int, sys.stdin.readline().split()))

def Hash():
	return dict()

def Mod():
	return 1000000007

def Ncr(n, r, p):
	return fact[n] * (ifact[r] * ifact[n - r] % p) % p

def Most_frequent(list):
	return max(set(list), key=list.count)

def Mat2x2(n):
	return [List() for _ in range(n)]

def btod(n):
	return int(n, 2)

def dtob(n):
	return bin(n).replace('0b', '')

def solution():
	for _ in range(Int()):
		n = Int()
		a = [0] + List()
		dp = [1] * (n + 1)
		for i in range(1, n + 1):
			for j in range(2 * i, n + 1, i):
				if a[i] < a[j]:
					dp[j] = max(dp[j], dp[i] + 1)
		print(max(dp))
solution()


import sys, os.path
from collections import *
from heapq import *
from copy import *
import math
mod = 10 ** 9 + 7
read = lambda : map(int, input().split())
inf = float('inf')
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
for t in range(int(input())):
	n = int(input())
	a = list(read())
	a = [-1] + a
	dp = [1 for i in range(n + 1)]

	def solve(i):
		ans = 0
		for i in range(1, n + 1):
			for j in range(i + i, n + 1, i):
				if a[j] > a[i]:
					dp[j] = max(dp[j], 1 + dp[i])
		return max(dp)
	print(solve(1))


import math
t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	dp = [1] * (n + 1)
	j = 1
	while j < n:
		r = j + 1
		i = 1
		while i <= math.sqrt(r):
			if r % i == 0:
				if b[r - 1] > b[i - 1]:
					dp[r] = max(dp[r], dp[i] + 1)
				if b[r - 1] > b[r // i - 1]:
					dp[r] = max(dp[r], dp[r // i] + 1)
			i += 1
		j += 1
	print(max(dp))


t = int(input())
while t:
	n = int(input())
	s = list(map(int, input().split()))
	dp = [0 for i in range(n + 1)]
	dp[1] = 1
	for i in range(2, n + 1):
		dp[i] = 1
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0:
				if s[i - 1] > s[j - 1]:
					dp[i] = max(dp[i], dp[j] + 1)
				if s[i - 1] > s[i // j - 1]:
					dp[i] = max(dp[i], dp[i // j] + 1)
	print(max(dp))
	t -= 1


def calc(s, prevs, idx, n, curcnt, mem):
	if curcnt <= mem[idx - 1]:
		return curcnt
	if s[idx - 1] <= prevs:
		return curcnt - 1
	mem[idx - 1] = curcnt
	res = curcnt
	for newidx in range(idx * 2, n + 1, idx):
		res = max(res, calc(s, s[idx - 1], newidx, n, curcnt + 1, mem))
	return res
_i = int(input())
for _ in range(_i):
	n = int(input())
	s = list(map(int, input().strip().split()))
	mem = [0] * n
	res = 0
	for idx in range(1, n // 2 + 2):
		res = max(res, calc(s, prevs=-1, idx=idx, n=n, curcnt=1, mem=mem))
	print(res)


for _ in range(int(input())):
	n = int(input())
	s = [int(x) for x in input().split()]
	a = [0]
	for i in s:
		a.append(i)
	bful = []
	for i in range(1, n + 1):
		temp = []
		j = 2 * i
		while j <= n:
			if a[j] > a[i]:
				temp.append(j)
			j += i
		bful.append(temp)
	cnt = [0]
	for i in s:
		cnt.append(0)
	brev = bful[::-1]
	for (i, j) in enumerate(brev):
		if len(j) == 0:
			cnt[n - i] = 1
		else:
			t = -1
			for k in j:
				if cnt[k] > t:
					t = cnt[k]
			cnt[n - i] = t + 1
	print(max(cnt))


T = int(input())
for t in range(T):
	n = int(input())
	A = [0] + [int(i) for i in input().split()]
	dp = [0] + [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if A[j] > A[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	c = 0
	dp = [1 for i in range(n)]
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j - 1] > a[i - 1]:
				dp[j - 1] = max(1 + dp[i - 1], dp[j - 1])
	print(max(dp))


t = int(input())

def max_models(s, n):
	max_answer = 0
	d = [0] * n
	for i in range(n - 1, -1, -1):
		d[i] = 1
		j = 2
		max_length = 0
		while j * (i + 1) <= n:
			if d[j * (i + 1) - 1] > max_length and s[i] < s[j * (i + 1) - 1]:
				max_length = d[j * (i + 1) - 1]
			j += 1
		d[i] += max_length
		if d[i] > max_answer:
			max_answer = d[i]
	return max_answer
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	print(max_models(s, n))


import sys

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
from math import *
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')

def li():
	return [int(x) for x in input().split()]

def fi():
	return int(input())

def si():
	return list(input().rstrip())

def mi():
	return map(int, input().split())
t = fi()
while t > 0:
	t -= 1
	n = fi()
	a = li()
	d = [1 for i in range(n + 1)]
	for i in range(n):
		p = i + 1
		for j in range(1, int(sqrt(p)) + 1):
			if p % j == 0:
				if a[i] > a[j - 1]:
					d[i] = max(d[i], d[j - 1] + 1)
				if a[i] > a[p // j - 1]:
					d[i] = max(d[i], d[p // j - 1] + 1)
	print(max(d))


import math

def div(n):
	i = 1
	d = []
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				d.append(i)
			else:
				d.append(i)
				d.append(n // i)
		i += 1
	d.sort()
	return d[0:len(d) - 1]
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n):
		d = div(i + 1)
		c = 1
		for j in d:
			if a[j - 1] < a[i]:
				c = max(dp[j - 1] + 1, c)
		dp[i] = c
	print(max(dp))


import math

def factors(i):
	result = set()
	for j in range(1, int(math.sqrt(i)) + 2):
		if i % j == 0:
			result.add(j)
			result.add(i // j)
	return result
t = int(input())
for _ in range(t):
	n = int(input())
	s = [int(x) for x in input().split()]
	dp = [1] * (n + 1)
	for i in range(2, n + 1):
		for factor in factors(i):
			if s[i - 1] > s[factor - 1]:
				dp[i] = max(dp[i], dp[factor] + 1)
	print(max(dp))


from collections import defaultdict

def f(x, d, s):
	k = 1
	res = 1
	while k * k <= x:
		(a, b) = (0, 0)
		if x % k == 0:
			if s[k - 1] != s[x - 1]:
				a = d[k] + 1
			if s[x // k - 1] != s[x - 1]:
				b = d[x // k] + 1
		k += 1
		res = max(a, b, res)
	d[x] = res
	return res
for _ in range(int(input())):
	d = defaultdict(int)
	n = int(input())
	s = list(map(int, input().split()))
	l1 = []
	for i in range(n):
		l1.append((s[i], i + 1))
	l = sorted(l1)
	dp = [0] * n
	for i in range(n):
		dp[i] = f(l[i][1], d, s)
	print(max(dp))


import sys
I = sys.stdin.readline
ans = ''

def func(ind, n, s):
	if ind >= n:
		return 0
	if dp[ind] != -1:
		return dp[ind]
	count = 0
	for k in range(2 * ind, n, ind):
		if s[k] > s[ind]:
			count = max(count, 1 + func(k, n, s))
	dp[ind] = count
	return dp[ind]
for _ in range(int(I())):
	n = int(I())
	s = list(map(int, I().split()))
	s.insert(0, 0)
	dp = [-1] * 100001
	maxi = 1
	for i in range(1, n + 1):
		maxi = max(maxi, 1 + func(i, n + 1, s))
	ans += str(maxi) + '\n'
print(ans)


def DFC(maxm, u):
	maxm += 1
	e[u] = maxm
	if len(st[u]) == 0:
		maxms.append(maxm)
		return 0
	for i in st[u]:
		if e[i] <= maxm:
			DFC(maxm, i)
	return 0
rw = int(input())
for ewqr in range(rw):
	n = int(input())
	maxms = []
	maxm = 0
	s = [0] + list(map(int, input().split()))
	st = [[] for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if s[i] < s[j]:
				st[i].append(j)
	e = [0] * (n + 1)
	for i in range(1, n + 1):
		if e[i] == 0:
			DFC(maxm, i)
	print(max(maxms))


def factors(n):
	from functools import reduce
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def main():
	for _ in range(int(input())):
		n = int(input())
		arr = [0] + list(map(int, input().split()))
		dp = [[0, 1] for i in range(n + 1)]
		dp[1][0] = 0
		dp[1][1] = 1
		for i in range(2, n + 1):
			dp[i][0] = max(dp[i - 1])
			facs = list(factors(i))
			for fac in facs:
				if arr[fac] < arr[i]:
					dp[i][1] = max(dp[i][1], 1 + dp[fac][1])
		print(max(dp[n]))
main()


from sys import stdin, stdout
from math import *
input = stdin.readline
for __ in range(int(input())):
	n = int(input())
	ar = list(map(int, input().split()))
	ar.insert(0, 0)
	n = n + 1
	dp = [1] * n
	for i in range(n, 0, -1):
		x = 2
		while i * x < n:
			if ar[i] < ar[i * x]:
				dp[i] = max(dp[i], dp[x * i] + 1)
			x += 1
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0]
	a.extend(b)
	ans = 1
	dp = [1] * (n + 1)
	for i in range(n // 2 + 1, 0, -1):
		ind = 2
		while i * ind <= n:
			if a[i] < a[i * ind]:
				dp[i] = max(dp[i], dp[i * ind] + 1)
			ind = ind + 1
		ans = max(ans, dp[i])
	print(ans)


def solve(n, s):
	h = {}
	for i in range(1, n // 2 + 1):
		for j in range(2 * i, n + 1, i):
			if s[i] < s[j]:
				if i not in h:
					h[i] = {}
				h[i][j] = 1
	mx = {}
	for i in reversed(sorted(h.keys())):
		mx[i] = max([1 + mx[j] if j in mx else 1 for j in h[i]])
	return 1 if not mx else max([mx[i] for i in mx]) + 1
t = int(input().strip())
for _ in range(t):
	n = int(input().strip())
	s = [0] + list(map(int, input().strip().split()))
	print(solve(n, s))


t = int(input())
for test in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	lengths = []
	for i in range(n):
		lengths.append(1)
	for i in range(n):
		for j in range(2 * i + 1, n, i + 1):
			if arr[i] < arr[j]:
				lengths[j] = max(lengths[j], lengths[i] + 1)
	print(max(lengths))


t = int(input())
for i in range(t):
	n = int(input())
	lst = list(map(int, input().split()))
	dic = [-1] * n

	def fun(ind):
		ma = 1
		for j in range(2 * (ind + 1), n + 1, ind + 1):
			if lst[j - 1] > lst[ind]:
				if dic[j - 1] != -1:
					ma = max(ma, 1 + dic[j - 1])
				else:
					a = fun(j - 1)
					dic[j - 1] = a
					ma = max(ma, 1 + a)
		return ma
	for j in range(n):
		if dic[j] == -1:
			dic[j] = fun(j)
	print(max(dic))


for _ in range(int(input())):
	n = int(input())
	a = [0] + list(map(int, input().strip().split(' ')))
	count = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j] > a[i]:
				count[j] = max(count[j], count[i] + 1)
	print(max(count))


import math

def find_divisors(n):
	ans = set()
	for i in range(1, int(math.sqrt(n)) + 1, 1):
		if n % i == 0:
			ans.add(i)
			ans.add(int(n / i))
	return ans

def solve(size, array):
	count = [1] * (size + 1)
	for i in range(1, size + 1, 1):
		for j in find_divisors(i):
			if array[j] < array[i]:
				count[i] = max(count[i], 1 + count[j])
	print(max(count))
testCases = int(input())
while testCases:
	N = int(input())
	A = [int(x) for x in input().split()]
	A = [-1] + A
	solve(N, A)
	testCases -= 1


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	divisors = [[] for i in range(n)]
	for i in range(n):
		for j in range(i, n, i + 1):
			divisors[j].append(i + 1)
	ans = [1 for i in range(n)]
	for i in range(n - 1, -1, -1):
		for j in range(len(divisors[i]) - 1):
			if arr[i] > arr[divisors[i][j] - 1]:
				ans[divisors[i][j] - 1] = max(ans[divisors[i][j] - 1], ans[i] + 1)
	print(max(ans))


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(t,) = I()
for _ in range(t):
	(n,) = I()
	l = I()
	an = [1] * n
	for i in range(1, n // 2 + 1):
		for j in range(2 * i - 1, n, i):
			if l[i - 1] < l[j]:
				an[j] = max(an[j], an[i - 1] + 1)
	print(max(an))


def helper(l):
	l.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j] > l[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)
for q in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	print(helper(l))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
import bisect as bi
import heapq

def I():
	return int(input())

def In():
	return map(int, input().split())

def printDivisors(n):
	i = 1
	ans = []
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				ans.append(i)
			else:
				ans.append(i)
				ans.append(n // i)
		i = i + 1
	return ans

def main():
	try:
		n = I()
		l = [0] + list(In())
		z = [1] * (n + 1)
		for i in range(1, n + 1):
			j = i * 2
			while j < n + 1:
				if l[i] < l[j]:
					z[j] = max(z[j], z[i] + 1)
				j += i
		print(max(z))
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(I()):
	main()


for _ in range(int(input())):
	n = int(input())
	s = map(int, input().split())
	s = list(s)
	d = [1] * n
	for i in range(n // 2, -1, -1):
		for nex in range(i + i + 1, n, i + 1):
			if s[i] < s[nex]:
				d[i] = max(d[i], 1 + d[nex])
	print(max(d))


def orac(n, a):
	f = [1] * (n + 1)
	maximum = 1
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j] > a[i]:
				if f[j] < f[i] + 1:
					f[j] = f[i] + 1
					if f[j] > maximum:
						maximum = f[j]
	print(maximum)
	return
t = int(input())
a = []
for i in range(t):
	n = int(input())
	array = [0]
	array.extend(list(map(int, input().split(' '))))
	a.append([n, array])
for x in a:
	orac(*x)


for i in range(int(input())):
	q = int(input())
	w = list(map(int, input().split()))
	a = [1] * (q + 1)
	for i in range(q):
		for j in range(2 * i + 1, q, i + 1):
			if w[j] > w[i]:
				a[j] = max(a[j], a[i] + 1)
	print(max(a))


for _ in range(int(input())):
	n = int(input())
	d = [1] * (n + 1)
	a = [int(x) for x in input().split()]
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if a[i - 1] < a[j - 1]:
				d[j] = max(d[j], d[i] + 1)
	print(max(d))


import sys
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def read():
	tc = 0
	if tc:
		input = sys.stdin.readline
	else:
		sys.stdin = open('input1.txt', 'r')
		sys.stdout = open('output1.txt', 'w')

def solve():
	for _ in range(ii()):
		n = ii()
		a = li()
		dp = [1] * (n + 1)
		dp[1] = 1
		for i in range(2, n + 1):
			p = [1]
			for j in range(2, int(sqrt(i)) + 1):
				if i % j == 0:
					p.append(j)
					if j != i // j:
						p.append(i // j)
			for j in p:
				if i % j == 0 and a[j - 1] < a[i - 1]:
					dp[i] = max(dp[i], dp[j] + 1)
		ans = 0
		for i in dp:
			ans = max(ans, i)
		print(ans)
solve()


from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
	return int(input())

def rl():
	return list(map(int, input().split()))

def solve():
	n = ri()
	S = [0] + rl()
	best = [1] * (n + 1)
	best_all = 0
	for p in range(1, n + 1):
		best_all = max(best_all, best[p])
		for q in range(2 * p, n + 1, p):
			if S[q] > S[p]:
				best[q] = max(best[q], best[p] + 1)
	print(best_all)
mode = 'T'
if mode == 'T':
	t = ri()
	for i in range(t):
		solve()
else:
	solve()


for _ in range(int(input())):
	n = int(input())
	ls = [int(x) for x in input().split()]
	l = [int(1000000000.0)]
	for i in ls:
		l.append(i)
	dp = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if j != i and l[j] > l[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


import math

def answer(n, A):
	dp = [0] * (n + 1)
	dp[1] = 1
	for i in range(2, n + 1):
		for j in range(1, int(math.sqrt(i)) + 1):
			if i % j == 0:
				if A[i - 1] > A[j - 1]:
					dp[i] = max(dp[i], 1 + dp[j])
				if i // j != i and A[i - 1] > A[i // j - 1]:
					dp[i] = max(dp[i], 1 + dp[i // j])
		if dp[i] == 0:
			dp[i] = 1
	return max(dp)
t = int(input())
for i in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	print(answer(n, s))


t = int(input())
for test in range(t):
	n = int(input())
	ar = [int(x) for x in input().split()]
	c_b = [0 for i in range(n + 1)]

	def check(indi):
		global n
		cc = []
		j = 3
		x = indi * 2
		while x <= n:
			if ar[x - 1] > ar[indi - 1]:
				cc.append(c_b[x])
			x = indi * j
			j += 1
		if len(cc) > 0:
			return max(cc)
		else:
			return 0
	for i in range(n - 1, -1, -1):
		c_b[i + 1] = check(i + 1) + 1
	print(max(c_b))


from sys import stdin
input = stdin.readline
import math
import bisect
for xoxo in range(1):
	for _ in range(int(input())):
		n = int(input())
		ans = [1] * n
		a = list(map(int, input().split()))
		for i in range(1, n + 1):
			if a[i - 1] > a[0]:
				ans[i - 1] += 1
			for j in range(2, math.floor(math.sqrt(i)) + 1):
				if i % j == 0:
					(x, y) = (i // j, j)
					if a[x - 1] < a[i - 1]:
						ans[i - 1] = max(ans[x - 1] + 1, ans[i - 1])
					if a[y - 1] < a[i - 1]:
						ans[i - 1] = max(ans[y - 1] + 1, ans[i - 1])
		print(max(ans))


t = int(input())
for m in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	s = [0] + s
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i] < s[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	res = 0
	for i in range(n + 1):
		res = max(res, dp[i])
	print(res)


t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	l = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[j - 1] > arr[i - 1]:
				l[j] = max(l[j], l[i] + 1)
	print(max(l))


from functools import reduce

def qq(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n):
		el = l[i]
		ind = i + 1
		k = qq(ind)
		for a in k:
			if a < ind and l[a - 1] < el:
				dp[ind] = max(dp[ind], dp[a] + 1)
	print(max(dp))


from functools import lru_cache
for ii in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = 0

	@lru_cache(None)
	def fun(ind, e):
		j = e
		for i in range(2, n // 2 + 2):
			if ind * i > n:
				break
			if arr[ind - 1] < arr[ind * i - 1]:
				temp = fun(ind * i, e + 1)
				j = max(j, temp)
		return j
	for i in range(1, n // 2 + 2):
		a = fun(i, 0)
		ans = max(ans, a + 1)
	print(ans)


from sys import stdin, stdout
input = lambda : stdin.readline().strip()
fast_print = stdout.write
from math import sqrt, floor
T = int(input())
for _ in range(T):
	n = int(input())
	ls = list(map(int, input().split()))
	matrix = []
	for i in range(len(ls) + 1):
		matrix.append([])
	for i in range(1, len(ls) + 1):
		for j in range(1, floor(sqrt(i)) + 1):
			if i % j == 0:
				if j != i and ls[j - 1] < ls[i - 1]:
					matrix[i].append(j)
				if i // j != i and ls[i // j - 1] < ls[i - 1] and (i // j != j):
					matrix[i].append(i // j)
	ans = []
	for i in range(len(ls) + 1):
		ans.append(1)
	for i in range(len(matrix)):
		try:
			temp = max((ans[j] for j in matrix[i]))
		except:
			temp = 0
		ans[i] = max(ans[i], temp + 1)
	fast_print(str(max(ans)) + '\n')


def solve(models):
	n = len(models) - 1
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if models[i] < models[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)
t = int(input())
for _ in range(t):
	n = int(input())
	models = [None] + list(map(int, input().split()))
	ans = solve(models)
	print(ans)


from sys import stdin, stdout
import math

def main():
	t = int(stdin.readline())
	for _ in range(t):
		n = int(stdin.readline())
		arr = [int(k) for k in input().split()]
		freq = [0] * (n + 1)
		for i in range(1, n + 1):
			for j in range(i * 2, n + 1, i):
				if arr[j - 1] > arr[i - 1]:
					freq[j] = max(freq[i] + 1, freq[j])
		result = 0
		for i in range(1, n + 1):
			result = max(result, freq[i])
		print(result + 1)
main()


import sys
import functools
import sys
x = 10000
sys.setrecursionlimit(1000000)

@functools.lru_cache(maxsize=None)
def sol(idx):
	if idx > len(l):
		return 0
	else:
		max_so_far = 0
		i = 2
		while idx * i <= len(l):
			if l[idx * i - 1] > l[idx - 1]:
				max_so_far = max(max_so_far, 1 + sol(idx * i))
			i += 1
		return max_so_far
t = int(sys.stdin.readline().strip())
for t0 in range(t):
	sol.cache_clear()
	n = int(sys.stdin.readline().strip())
	l = list(map(int, sys.stdin.readline().strip().split(' ')))
	max_so_far = 0
	for x in range(1, len(l) + 1):
		max_so_far = max(max_so_far, 1 + sol(x))
	print(max_so_far)


t = int(input())
for i in range(0, t):
	n = int(input())
	a = input().strip().split()
	a = [int(x) for x in a]
	dp = [1] * (n + 1)
	for j in range(1, n + 1):
		for k in range(j * 2, n + 1, j):
			if a[k - 1] > a[j - 1]:
				dp[k] = max(dp[k], dp[j] + 1)
	print(max(dp))


t = int(input())
answers = []
for _ in range(t):
	n = int(input())
	sizes = [None]
	sizes += [int(i) for i in input().split()]
	store = [None for i in range(n + 1)]
	for i in range(n):
		index = n - i
		mult = 2
		best = 1
		for mult in range(2, int(n / index) + 1):
			to_be_considered = mult * index
			s = sizes[to_be_considered]
			if s > sizes[index]:
				best = max(best, 1 + store[to_be_considered])
		store[index] = best
	answers.append(max(store[1:]))
print(*answers, sep='\n')


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip()
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
test = int(input())

def divisors(n):
	ans = []
	d = 1
	while d * d <= n:
		if d * d == n:
			ans.append(d)
		elif n % d == 0:
			ans.append(d)
			ans.append(n // d)
		d += 1
	return ans
for _ in range(test):
	n = int(input())
	a = [int(x) for x in input().split()]
	dp = [1 for i in range(n)]
	for i in range(n):
		act_idx = i + 1
		for d in divisors(act_idx):
			prev_idx = d - 1
			if a[prev_idx] < a[i]:
				dp[i] = max(dp[i], dp[prev_idx] + 1)
	print(max(dp))


t = int(input())
for you in range(t):
	n = int(input())
	l = input().split()
	li = [int(i) for i in l]
	dp = [0 for i in range(n)]
	dp[0] = 1
	for i in range(1, n):
		j = 1
		lo = []
		while j * j <= i + 1:
			if (i + 1) % j == 0:
				poss1 = j
				poss2 = (i + 1) // j
				if li[i] > li[poss1 - 1]:
					lo.append(dp[poss1 - 1] + 1)
				if poss1 != poss2:
					if li[i] > li[poss2 - 1]:
						lo.append(dp[poss2 - 1] + 1)
			j += 1
		if lo == []:
			dp[i] = 1
		else:
			dp[i] = max(lo)
	print(max(dp))


q = int(input())
for i in range(q):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1] * n
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i - 1] < s[j - 1]:
				dp[j - 1] = max(dp[j - 1], dp[i - 1] + 1)
	print(max(dp))


def ri():
	return int(input())

def ria():
	return list(map(int, input().split()))

def main():
	for _ in range(ri()):
		n = ri()
		s = ria()
		d = [1] * (n + 1)
		for i in range(1, n + 1):
			for j in range(2, n // i + 1):
				if s[i - 1] < s[i * j - 1]:
					d[i * j] = max(d[i * j], d[i] + 1)
		print(max(d))
main()


import sys
import bisect
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(int(ri())):
	n = int(ri())
	a = Ri()
	a = [0] + a
	dp = [1] * (n + 1)
	maxx = 1
	for i in range(1, len(a)):
		tmax = 0
		p = 1
		while p * p <= i:
			if i % p == 0 and p != i and (a[p] < a[i]):
				tmax = max(tmax, dp[p])
			if i % p == 0 and i // p != i and (a[i // p] < a[i]):
				tmax = max(tmax, dp[i // p])
			p += 1
		dp[i] = max(dp[i], tmax + 1)
		maxx = max(maxx, dp[i])
	print(maxx)


def DP(i_j):
	if i_j in memo_table:
		return memo_table[i_j]
	else:
		x = 2
		temp = 1
		while x * i_j <= n:
			if s[x * i_j] > s[i_j]:
				if temp < 1 + DP(x * i_j):
					temp = 1 + DP(x * i_j)
			x += 1
		memo_table[i_j] = temp
		return memo_table[i_j]
t = int(input())
for test in range(t):
	memo_table = {}
	n = int(input())
	s = list(map(int, input().split()))
	s.insert(0, 0)
	ans = DP(1)
	for i in range(1, n):
		if DP(i) > ans:
			ans = DP(i)
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	dp = [0 for i in range(n + 1)]
	for i in range(1, n + 1):
		ds = []
		j = 1
		while j * j <= i:
			if i % j == 0:
				ds.append(j)
				if j * j != i:
					ds.append(i // j)
			j += 1
		for j in ds:
			if a[i] > a[j]:
				dp[i] = max(dp[i], dp[j] + 1)
		dp[i] = max(dp[i], 1)
	print(max(dp))


def main():
	t = int(input())
	while t:
		n = int(input())
		a = list(map(int, input().split()))
		f = [1 for _ in range(n + 1)]
		for i in range(1, n + 1):
			for j in range(i * 2, n + 1, i):
				if a[j - 1] > a[i - 1]:
					f[j] = max(f[j], f[i] + 1)
		print(max(f))
		t -= 1
main()


def solve(n, s):
	dp = [0] + [1] * n
	for i in range(1, n + 1):
		for m in range(i * 2, n + 1, i):
			if s[i] < s[m]:
				dp[m] = max(dp[m], dp[i] + 1)
	ans = max(dp)
	return ans
for t in range(int(input())):
	n = int(input())
	s = [0] + list(map(int, input().split()))
	print(solve(n, s))


import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
	f = iter(open('B.txt').readlines())

	def input():
		return next(f)
else:
	input = sys.stdin.readline

def func(k):
	return k * (k + 1) // 2 * 3 - k
t = int(input())
for _ in range(t):
	n = int(input())
	S = [0] + list(map(int, input().split()))
	r = [1] * len(S)
	for (n, s) in enumerate(S):
		if n == 0:
			continue
		for k in range(n * 2, len(S), n):
			if S[k] > S[n]:
				r[k] = max(r[k], r[n] + 1)
	print(max(r))


def find_max_models(n, arr, curr, counter):
	size = arr[curr - 1]
	global ans
	count = curr * 2
	while count <= n:
		if size < arr[count - 1]:
			find_max_models(n, arr, count, counter + 1)
		count = count + curr
	ans = max(counter, ans)
numquery = int(input())
for _ in range(numquery):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = 1
	for i in range(1, n // 2):
		if i * 2 ** (ans - 1) > n:
			break
		find_max_models(n, arr, i, 1)
	print(ans)


for _ in range(int(input())):
	n = int(int(input()))
	ar = list(map(int, input().split()))
	li = [1] * n
	for i in range(1, n + 1):
		ini = i - 1
		for j in range(i + i, n + 1, i):
			if ar[j - 1] > ar[ini]:
				li[j - 1] = max(li[j - 1], li[ini] + 1)
	print(max(li))


from math import sqrt
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	dp = [1 for i in range(n)]
	dp[0] = 1
	best = 1
	for i in range(1, n):
		fact = set()
		for j in range(1, int(sqrt(i + 1)) + 1):
			if (i + 1) % j == 0:
				fact.add((i + 1) // j)
				fact.add(j)
		for j in fact:
			if j != i + 1 and a[i] > a[j - 1]:
				dp[i] = max(dp[i], dp[j - 1] + 1)
				best = max(best, dp[i])
	print(best)


from sys import stdin

def main():
	t = int(stdin.readline())
	for _ in range(t):
		n = int(stdin.readline())
		ar = list(map(int, input().split()))
		dp = [1] * (n + 1)
		for i in range(2, n):
			if ar[i - 1] > ar[0]:
				dp[i - 1] = max(dp[i - 1], dp[0] + 1)
		for i in range(2, n + 1):
			for j in range(i + i, n + 1, i):
				if ar[j - 1] > ar[i - 1]:
					dp[j - 1] = max(dp[i - 1] + 1, dp[j - 1])
		print(max(dp))
main()


import sys
import math
import bisect

def main():
	for _ in range(int(input())):
		n = int(input())
		A = list(map(int, input().split()))
		B = [1] * n
		for i in range(n):
			s = i + 1
			for t in range(s, n + 1, s):
				j = t - 1
				if A[j] > A[i]:
					B[j] = max(B[j], B[i] + 1)
		print(max(B))
main()


t = int(input())
while t > 0:
	t = t - 1
	n = int(input())
	a = input()
	A = list(map(int, list(a.split())))
	table = [1] * n
	for i in range(1, n):
		j = 0
		while j * j <= n:
			if (i + 1) % (j + 1) == 0:
				if A[j] < A[i]:
					table[i] = max(table[i], 1 + table[j])
				if A[(i + 1) // (j + 1) - 1] < A[i]:
					table[i] = max(table[i], table[(i + 1) // (j + 1) - 1] + 1)
			j = j + 1
	print(max(table))


from sys import stdin
for _ in range(int(input())):
	n = int(stdin.readline().rstrip())
	l = list(map(int, stdin.readline().rstrip().split(' ')))
	z = [0] * (n + 1)
	z[1] = 1
	for i in range(n, 1, -1):
		j = 2
		c = 0
		while i * j <= n:
			if l[i - 1] < l[i * j - 1]:
				c = max(c, z[i * j])
			j += 1
		z[i] = c + 1
	m = 1
	for i in range(2, n + 1):
		if l[0] < l[i - 1]:
			z[i] += 1
		m = max(m, z[i])
	print(m)


import math
T = int(input())

def gen_divisions(x):
	ret = set()
	for d in range(1, int(math.sqrt(i)) + 1):
		ret.add(d)
		ret.add(x // d)
	return ret
for _ in range(T):
	n = int(input())
	ss = [10 ** 10] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for (i, s) in enumerate(ss):
		if i == 0:
			continue
		for d in gen_divisions(i):
			if i % d == 0 and ss[d] < s:
				dp[i] = max(dp[i], dp[d] + 1)
	print(max(dp[1:]))


import sys
from math import *
from functools import *
t = int(input())
for _ in range(t):
	n = int(input())
	a = [0] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(n, 0, -1):
		k = 2
		j = i
		maxx = 0
		while j * k <= n:
			if a[j * k] > a[j]:
				maxx = max(maxx, dp[j * k])
			k += 1
		dp[i] = 1 + maxx
	print(max(dp))


t = int(input())
ans = []
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	c = [1] * (n + 1)
	for j in range(n // 2, 0, -1):
		for k in range(2 * j, n + 1, j):
			if arr[k - 1] > arr[j - 1]:
				c[j] = max(c[j], c[k] + 1)
	print(max(c))


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
test = int(input())
for _ in range(test):
	n = int(input())
	arr = list(map(int, input().split()))
	cntval = [0 for i in range(n + 1)]
	cntval[1] = 1
	for i in range(2, n + 1):
		cntval[i] = 1
	for i in range(2, n + 1):
		maxval = 0
		ans = factors(i)
		fac = []
		for val in ans:
			if arr[val - 1] < arr[i - 1]:
				fac.append(cntval[val])
		if fac != []:
			cntval[i] = max(fac) + 1
	print(max(cntval))


test = int(input())
for _ in range(test):
	n = int(input())
	l = list(map(int, input().split()))
	dp = [1] * n
	i = n // 2 - 1
	while i >= 0:
		maxi = 0
		j = 2
		while (i + 1) * j <= n:
			k = (i + 1) * j - 1
			if l[k] > l[i]:
				maxi = max(dp[k], maxi)
			j += 1
		dp[i] += maxi
		i -= 1
	print(max(dp))


t = int(input())
while t:
	t -= 1
	n = int(input())
	arr = list(map(int, input().strip().split()))
	lst = []
	lst.append(0)
	lst2 = [1 for i in range(n + 1)]
	for i in range(0, n):
		lst.append(arr[i])
	for i in range(n, 0, -1):
		for j in range(i + i, n + 1, i):
			if lst[j] > lst[i]:
				lst2[i] = max(lst2[i], lst2[j] + 1)
	su = 1
	for i in range(0, n + 1):
		su = max(su, lst2[i])
	print(su)


import math

def divisors(x):
	out = [[i, x // i] if not i == x // i else [i] for i in range(2, math.ceil(math.sqrt(x)) + 1) if not x % i]
	return [1] + [x for i in out for x in i]
cases = int(input())
for case in range(cases):
	n = int(input())
	a = [-1] + [int(x) for x in input().split()]
	magic = [1] * len(a)
	for i in range(2, len(magic)):
		for x in divisors(i):
			if a[x] < a[i]:
				magic[i] = max(magic[i], magic[x] + 1)
	print(max(magic))


for _ in range(int(input())):
	n = int(input())
	ar = [0] * 100001
	dp = [0] * 100001
	s = list(map(int, input().split()))
	for i in range(1, n + 1):
		ar[i] = s[i - 1]
		dp[i] = 1
	a = 1
	for i in range(2, n + 1):
		m = 0
		j = 1
		while j * j <= i:
			if i % j == 0:
				d1 = j
				d2 = int(i / j)
				if ar[d1] < ar[i]:
					m = max(m, dp[d1])
				if ar[d2] < ar[i]:
					m = max(m, dp[d2])
			j += 1
		dp[i] += m
		a = max(a, dp[i])
	print(a)


import sys
input = iter(sys.stdin.readlines()).__next__
t = int(input())
for _ in range(t):
	n = int(input())
	s = [None] + list(map(int, input().split()))
	scores = [0] * (n + 1)
	for i in reversed(range(1, n + 1)):
		scores[i] = 1 + max((scores[j] for j in range(i * 2, n + 1, i) if s[i] < s[j]), default=0)
	print(max(scores))


for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	ans = 0

	def dfs(num, M, L):
		global ans
		if 2 * num > n:
			ans = max(ans, L)
		else:
			ans = max(ans, L)
			for i in range(2, n // num + 1):
				if s[i * num] > M:
					dfs(i * num, s[i * num], L + 1)
	s = [0] + s
	for i in range(1, n + 1):
		dfs(i, s[i], 1)
	print(ans)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	r = [1] * (n + 1)
	for i in range(1, n // 2 + 1):
		j = 2 * i
		while j < n + 1:
			if a[j] > a[i]:
				r[j] = max(r[j], r[i] + 1)
			j += i
	print(max(r))


import sys
re = 0
n = 0
s = []

def goback(x, cnt):
	global re
	global n
	global s
	if re < cnt:
		re = cnt
	j = 2
	while True:
		if (x + 1) * j > n:
			break
		if s[(x + 1) * j - 1] > s[x]:
			goback((x + 1) * j - 1, cnt + 1)
		j += 1
for _ in range(int(sys.stdin.readline().rstrip())):
	n = int(sys.stdin.readline().rstrip())
	s = list(map(int, sys.stdin.readline().rstrip().split()))
	re = 0
	for i in range(n):
		goback(i, 1)
	print(re)


printn = lambda x: print(x, end='')
import sys
input = sys.stdin.readline
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
ins = lambda : input().strip()
DBG = True
BIG = 10 ** 18
R = 10 ** 9 + 7

def ddprint(x):
	if DBG:
		print(x)
import math

def isprime(x):
	q = int(math.sqrt(x))
	for i in range(2, q + 1):
		if x % i == 0:
			return False
	return True

def prime_division(x):
	q = int(math.sqrt(x))
	a = []
	for i in range(2, q + 1):
		ex = 0
		while x % i == 0:
			ex += 1
			x //= i
		if ex > 0:
			a.append([i, ex])
	if x > q:
		a.append([x, 1])
	return a

def divisorlist(z):
	if len(z) == 1:
		return [z[0][0] ** i for i in range(z[0][1] + 1)]
	y = divisorlist(z[1:])
	s = []
	for i in range(z[0][1] + 1):
		for j in y:
			s.append(z[0][0] ** i * j)
	return s
t = inn()
for tt in range(t):
	n = inn()
	s = inl()
	s[0:0] = [0]
	d = [1] * (n + 1)
	for i in range(n, 1, -1):
		divs = divisorlist(prime_division(i))
		for j in divs:
			if s[j] < s[i]:
				d[j] = max(d[j], d[i] + 1)
	print(max(d))


t = int(input())
for i in range(t):
	n = int(input())
	nums = list(map(int, input().split()))
	best = [1] * (n + 5)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if nums[i - 1] < nums[j - 1]:
				best[j] = max(best[j], best[i] + 1)
	print(max(best))


def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	return divisors
(T,) = map(int, input().split())
for t in range(T):
	(N,) = map(int, input().split())
	X = [0] + list(map(int, input().split()))
	dp = [1] * (N + 1)
	for i in range(1, N + 1):
		tmp = make_divisors(i)
		for j in tmp:
			if X[j] < X[i]:
				dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	sl = list(map(int, input().split()))
	sl = [0] + sl
	fl = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if sl[i] < sl[j]:
				fl[j] = max(fl[j], fl[i] + 1)
	ans = 0
	for i in range(1, n + 1):
		ans = max(ans, fl[i])
	print(ans)


from sys import stdin
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	size = list(map(int, stdin.readline().split()))
	dp = [1] * n
	for i in range(2, n + 1):
		y = {1}
		for j in range(2, int(i ** 0.5) + 1):
			if not i % j:
				y.add(j)
				y.add(i // j)
		for x in y:
			if size[i - 1] > size[x - 1]:
				dp[i - 1] = max(dp[i - 1], dp[x - 1] + 1)
	print(max(dp))


def fun(ind, n, l, dp):
	if dp[ind] != -1:
		return dp[ind]
	if ind > n:
		return 0
	count = 0
	for i in range(ind * 2, n + 1, ind):
		if l[i] > l[ind]:
			count = max(count, 1 + fun(i, n, l, dp))
	dp[ind] = count
	return dp[ind]

def solve():
	n = int(input())
	l = [int(x) for x in input().split()]
	ans = -1
	l.insert(0, -1)
	dp = [-1] * 100005
	for i in range(1, n + 1):
		ans = max(ans, 1 + fun(i, n, l, dp))
	print(ans)
for _ in range(int(input())):
	solve()


from sys import stdin
for case in range(int(stdin.readline())):
	n = int(stdin.readline())
	nums = [int(x) for x in stdin.readline().split()]
	newNums = {x + 1: nums[x] for x in range(n)}
	length = {x: 1 for x in range(1, n + 1)}
	for x in range(n, 0, -1):
		cur = x * 2
		while cur <= n:
			if newNums[cur] > newNums[x]:
				length[x] = max(length[x], length[cur] + 1)
			cur += x
	print(max([length[x] for x in length]))


def buy(n, models):
	models = [0] + models
	depth_list = [0 for i in range(n + 1)]

	def dfs(index):
		if depth_list[index]:
			return depth_list[index]
		size = models[index]
		depth = 1
		upb = int(n // index)
		for d in range(2, upb + 1):
			if models[index * d] > size:
				depth = max(dfs(index * d) + 1, depth)
		depth_list[index] = depth
		return depth
	for i in range(1, n + 1):
		dfs(i)
	return max(depth_list)
t = int(input())
for i in range(t):
	n = int(input())
	models = [int(s) for s in input().split()]
	print(buy(n, models))


def solve():
	n = int(input()) + 1
	arr = list(map(int, input().split()))
	ans = [1] * n
	for i in range(1, n):
		for j in range(2 * i, n, i):
			if arr[j - 1] > arr[i - 1]:
				ans[j] = max(ans[j], ans[i] + 1)
	print(max(ans))
for _ in range(int(input())):
	solve()


for _ in range(int(input())):
	n = int(input())
	arr = [0] + [int(__) for __ in input().split()]
	if n == 1:
		print(1)
		continue
	models = [1 for ___ in range(n)]
	for i in range(2, n + 1):
		max_ = 1
		for j in range(1, int(i ** 0.5) + 1):
			if j == 1:
				if arr[1] < arr[i] and max_ < models[0] + 1:
					max_ = models[0] + 1
			elif i % j == 0:
				if arr[j] < arr[i] and max_ < models[j - 1] + 1:
					max_ = models[j - 1] + 1
				if arr[i // j] < arr[i] and max_ < models[i // j - 1] + 1:
					max_ = models[i // j - 1] + 1
		models[i - 1] = max_
	print(max(models))


def main():
	n = int(input())
	a = [0]
	a.extend(list(map(int, input().split())))
	dp = [1 for _ in range(n + 1)]
	for i in range(1, n + 1):
		if 2 * i <= n:
			for j in range(2 * i, n + 1, i):
				if j <= n:
					if a[i] < a[j]:
						dp[j] = max(dp[j], dp[i] + 1)
				else:
					break
	print(max(dp))

def test():
	t = int(input())
	while t:
		main()
		t -= 1
test()


import math

def findAllFactors(n):
	factors = [1]
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			factors.append(i)
			factors.append(n // i)
	return factors
t = int(input())
for i in range(t):
	n = int(input())
	sizes = list(map(int, input().split()))
	sizes.insert(0, 0)
	dp = [1] * len(sizes)
	ans = 1
	for i in range(2, n + 1):
		facts = findAllFactors(i)
		count = 1
		for j in range(len(facts)):
			if sizes[facts[j]] < sizes[i]:
				count = max(count, dp[facts[j]] + 1)
		dp[i] = count
		ans = max(ans, count)
	print(ans)


from sys import stdin
from collections import Counter, deque
from itertools import product
input = stdin.buffer.readline
T = int(input())
for _ in range(T):
	n = int(input())
	ls = list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2, n + 1):
			p = i * j
			if p > n:
				break
			if ls[i - 1] < ls[p - 1]:
				dp[p] = max(dp[p], dp[i] + 1)
	print(max(dp))


tc = int(input())
for zzz in range(tc):
	n = int(input())
	arr = list(map(int, input().split()))
	s = len(arr)
	brr = [0] * (s + 1)
	ele = [0] * (s + 1)
	for i in range(s):
		brr[i + 1] = arr[i]
	for i in range(s, 0, -1):
		ele[i] += 1
		j = 1
		m = 0
		while i * j <= s:
			v = i * j
			if brr[i] < brr[v]:
				m = max(m, ele[v])
			j += 1
		ele[i] += m
	print(max(ele))


import sys
from collections import Counter

def get_ints():
	return list(map(int, sys.stdin.readline().strip().split()))
sys.setrecursionlimit(20000)
T = int(input())
for _ in range(T):
	n = int(input())
	S = get_ints()
	dp = [1] * (n + 1)
	for i in range(1, len(S) + 1):
		for j in range(i * 2, n + 1, i):
			if S[j - 1] > S[i - 1]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		n = I()
		l = [0] + list(In())
		dp = [1 for x in range(n + 1)]
		ans = 1
		for i in range(1, n + 1):
			t = i * 2
			while t <= n:
				if l[t] > l[i]:
					dp[t] = max(dp[i] + 1, dp[t])
					ans = max(ans, dp[t])
				t += i
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(I()):
	main()


def beautiful(data, n):
	dp = [1] * n
	for i in range(n // 2 - 1, 0, -1):
		for j in range(2 * i, n, i):
			if data[j] > data[i]:
				dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))
for i in range(int(input())):
	n = int(input())
	data = list(map(int, input().split()))
	data.insert(0, 0)
	beautiful(data, n + 1)


import sys
import math
t = int(input())
for i in range(t):
	n = int(input())
	a = input().split(' ')
	a = [int(aa) for aa in a]
	maxdp = [0] * n
	for i in range(n, 0, -1):
		maxc = 1
		k = 2 * i
		while k <= n:
			if a[k - 1] > a[i - 1]:
				maxc = max(maxc, maxdp[k - 1] + 1)
			k = k + i
		maxdp[i - 1] = maxc
	print(max(maxdp))


def solve(arr, dp, n):
	maxx = 0
	for i in range(1, n + 1):
		index = i
		while index <= n:
			if arr[index] > arr[i]:
				dp[index] = max(dp[index], dp[i] + 1)
			maxx = max(maxx, dp[index])
			index += i
	return maxx
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(i) for i in input().split()]
	arr.insert(0, 0)
	dp = [int(1) for i in range(n + 1)]
	print(solve(arr, dp, n))


t = int(input())
for test in range(t):
	n = int(input())
	arr = [int(x) for x in input().split()]
	can_bring = [0 for i in range(n + 1)]

	def check(ind):
		global n
		c = []
		j = 3
		x = ind * 2
		while x <= n:
			if arr[x - 1] > arr[ind - 1]:
				c.append(can_bring[x])
			x = ind * j
			j += 1
		if len(c) > 0:
			return max(c)
		else:
			return 0
	for i in range(n - 1, -1, -1):
		can_bring[i + 1] = check(i + 1) + 1
	print(max(can_bring))


import sys
import math

def inputnum():
	return int(input())

def inputnums():
	return map(int, input().split())

def inputlist():
	return list(map(int, input().split()))

def inputstring():
	return [x for x in input()]
t = int(input())
for q in range(t):
	n = inputnum()
	s = inputlist()
	v = [1] * (n + 1)
	ans = 1
	for i in reversed(range(1, n + 1)):
		cur = 2
		temp = 0
		while i * cur <= n:
			if s[i * cur - 1] > s[i - 1]:
				temp = max(temp, v[cur * i])
			cur += 1
		v[i] += temp
		ans = max(ans, v[i])
	print(ans)


from sys import stdin
from collections import defaultdict
t = int(stdin.readline())
while t > 0:
	count = 0
	s = defaultdict(lambda : 0)
	n = int(stdin.readline())
	arr = [int(x) for x in stdin.readline().split()]
	arr.insert(0, 0)
	ans = [1] * (n + 1)
	res = 0
	for i in range(n // 2, 0, -1):
		j = 2
		while i * j <= n:
			if ans[j * i] + 1 > ans[i] and arr[i] < arr[i * j]:
				ans[i] = ans[i * j] + 1
			j += 1
	print(max(ans))
	t -= 1


def recurrd(li, i, n, dp):
	if i == n:
		return 1
	maxx = 1
	for j in range(i * 2, n + 1, i):
		if li[j] > li[i]:
			if dp[j] == -1:
				count = recurrd(li, j, n, dp)
				dp[j] = count
			else:
				count = dp[j]
			maxx = max(maxx, 1 + count)
	return maxx

def solve():
	n = int(input())
	li = [0] + [int(x) for x in input().split()]
	dp = [-1] * (n + 1)
	maxx = 1
	for i in range(1, n + 1):
		val = recurrd(li, i, n, dp)
		maxx = max(maxx, val)
	print(maxx)
t = int(input())
for i in range(t):
	solve()


import math
import os
import random
import re
import sys

def algo(n, s):
	if n == 1:
		return 1
	r = [1] * 100000
	for i in range(1, n + 1):
		m = 2
		a = s[i - 1]
		while m * i <= n:
			b = s[m * i - 1]
			if b > a and r[m * i - 1] <= r[i - 1]:
				r[m * i - 1] = r[i - 1] + 1
			m += 1
	return max(r)
for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	print(algo(n, s))


def get_divisors(x):
	if x == 1:
		return
	yield 1
	i = 2
	while i * i <= x:
		if x % i == 0:
			yield i
			yield (x // i)
		i += 1
t = int(input())
for _ in range(t):
	n = int(input())
	s = [0] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for (i, e) in enumerate(s[1:], 1):
		for j in get_divisors(i):
			if s[j] < e:
				dp[i] = max(dp[i], dp[j] + 1)
	ans = max(dp)
	print(ans)


t = int(input())
for v in range(t):
	n = int(input())
	l = list(map(int, input().split(' ')))
	dp = [1] * (n + 1)
	li = [0] * (n + 1)
	for i in range(n):
		li[i + 1] = l[i]
	for i in range(1, n + 1):
		j = 2 * i
		while j < n + 1:
			if li[j] > li[i]:
				dp[j] = max(dp[j], dp[i] + 1)
			j += i
	ans = dp[1]
	for i in range(2, n + 1):
		if dp[i] > ans:
			ans = dp[i]
	print(ans)


from functools import lru_cache
import sys
import threading

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		nums = [0] + list(map(int, input().split()))
		dp = [1] * (n + 1)
		for (idx, num) in enumerate(nums):
			if idx == 0:
				continue
			for j in range(idx + idx, n + 1, idx):
				if nums[j] > nums[idx]:
					dp[j] = max(dp[j], dp[idx] + 1)
		print(max(dp))
main()


def HalfDead():
	n = int(input())
	a = [int(x) for x in input().split()]
	l = [int(1000000000.0)]
	for i in a:
		l.append(i)
	dp = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if j != i and l[j] > l[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)
for _ in range(int(input())):
	print(HalfDead())


from math import sqrt, ceil
from collections import defaultdict

def fun(n):
	indices = [1]
	for j in range(2, int(ceil(sqrt(n))) + 1):
		if n % j == 0:
			indices.append(j)
			indices.append(int(n / j))
	return indices
for _ in range(int(input())):
	N = int(input())
	List = [int(x) for x in input().split()]
	dp = [1] * (N + 1)
	for i in range(1, N + 1):
		for j in range(i * 2, N + 1, i):
			if List[i - 1] < List[j - 1]:
				dp[j] = max(dp[i] + 1, dp[j])
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	long = [1 for i in range(n)]
	ans = 0
	for i in range(n // 2, 0, -1):
		j = 2
		max_ = 0
		s_i = 0
		while i * j <= n:
			next_index = i * j - 1
			now_index = i - 1
			if s[next_index] > s[now_index]:
				if long[next_index] > max_:
					max_ = long[next_index]
					s_i = s[next_index]
			j += 1
		long[i - 1] = max_ + 1
	print(max(long))


linp = 'list(map(int,input().split()))'
t = int(input())
for T in range(t):
	n = int(input())
	v = eval(linp)
	v = [0] + v
	dp = [0] * (n + 1)
	dp[-1] = 1
	for i in range(n - 1, 0, -1):
		for j in range(i + i, n + 1, i):
			if v[j] > v[i]:
				dp[i] = max(dp[i], dp[j])
		dp[i] += 1
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	s = [10000000000] + s
	dp = [1] * (n + 1)
	for i in range(2, 1 + n):
		for j in range(1, 1 + int(i ** 0.5)):
			if i % j == 0 and s[j] < s[i]:
				dp[i] = max(dp[j] + 1, dp[i])
			q = i // j
			if q != j and i % q == 0 and (s[q] < s[i]):
				dp[i] = max(dp[q] + 1, dp[i])
	print(max(dp))


from sys import stdin, stdout, setrecursionlimit
import threading

class Tail_Recursion_Optimization:

	def __init__(self, RECURSION_LIMIT, STACK_SIZE):
		setrecursionlimit(RECURSION_LIMIT)
		threading.stack_size(STACK_SIZE)
		return None

class SOLVE:

	def solve(self):
		R = stdin.readline
		W = stdout.write
		ans = []
		for i in range(int(R())):
			n = int(R())
			a = [0] + [int(x) for x in R().split()]
			dp = [1 for j in range(n + 1)]
			for j in range(1, n + 1):
				for k in range(2 * j, n + 1, j):
					if a[j] < a[k]:
						dp[k] = max(1 + dp[j], dp[k])
			mx = 1
			for j in range(1, n + 1):
				mx = max(mx, dp[j])
			ans.append(str(mx))
		W('\n'.join(ans))
		return 0

def main():
	s = SOLVE()
	s.solve()
main()


def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
entries = inp()
for i in range(entries):
	n = inp()
	l = inlt()
	val = 1
	for j in range(n):
		multipliers_evaluating = [2]
		loc = [j + 1]
		while len(multipliers_evaluating):
			new_loc = loc[-1] * multipliers_evaluating[-1]
			if loc[0] * multipliers_evaluating[0] > n:
				break
			if new_loc >= n + 1:
				loc.pop(-1)
				multipliers_evaluating.pop(-1)
				multipliers_evaluating[-1] += 1
			elif l[new_loc - 1] > l[loc[-1] - 1]:
				multipliers_evaluating.append(2)
				loc.append(new_loc)
				if len(multipliers_evaluating) > val:
					val = len(multipliers_evaluating)
			else:
				multipliers_evaluating[-1] += 1
	print(val)


def lis(l):
	lis = [1] * (len(l) + 1)
	for i in range(1, len(l) + 1):
		for j in range(i * 2, len(l) + 1, i):
			if l[i - 1] < l[j - 1]:
				lis[j] = max(lis[j], lis[i] + 1)
	return max(lis)
n = int(input())
for i in range(n):
	k = int(input())
	l = list(map(int, input().split()))
	print(lis(l))


def readInt():
	return int(input())

def readList():
	return list(map(int, input().rstrip().split()))

def readString():
	s = input()
	return s

def readInts():
	return map(int, input().rstrip().split())
memo = {}

def solve(n, arr):
	dp = [1] * n
	for i in range(n - 1, -1, -1):
		for j in range(i + (i + 1), n, i + 1):
			if (j + 1) % (i + 1) == 0 and arr[j] > arr[i]:
				dp[i] = max(dp[i], 1 + dp[j])
	print(max(dp))
t = readInt()
for i in range(t):
	memo = {}
	n = readInt()
	arr = readList()
	solve(n, arr)


t = int(input())
for q in range(t):
	n = int(input())
	mass = [int(x) for x in input().split()]
	arr = [1] * n
	answer = 1
	for i in range(n - 1, -1, -1):
		for j in range(2, n // (i + 1) + 1):
			if arr[i] < arr[j * (i + 1) - 1] + 1 and mass[i] < mass[j * (i + 1) - 1]:
				arr[i] = arr[j * (i + 1) - 1] + 1
		if arr[i] > answer:
			answer = arr[i]
	print(answer)


from math import floor, sqrt

def dl(n):
	d = []
	if n == 2:
		return [1]
	for j in range(1, floor(sqrt(n)) + 2):
		if n % j == 0:
			d.append(j)
			if j != 1:
				d.append(n // j)
	return d

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		arr = list(map(int, input().split()))
		if n == 1:
			print(1)
		else:
			f = [0] * (n + 1)
			f[1] = 1
			for j in range(2, n + 1):
				mx = 0
				for k in dl(j):
					if arr[k - 1] < arr[j - 1]:
						if f[k] > mx:
							mx = f[k]
				f[j] = mx + 1
			mx = 0
			for j in f:
				if j > mx:
					mx = j
			print(mx)
main()


import sys

def read_integer():
	return int(sys.stdin.readline())

def read_integers():
	return [int(x) for x in sys.stdin.readline().split(' ')]

def print_integers(nums):
	print(' '.join([str(x) for x in nums]))

def func():
	m = read_integer() + 1
	nums = [-1] + read_integers()
	f = [-1 for _ in range(m)]

	def dfs(index):
		if f[index] != -1:
			return f[index]
		ret = 0
		for i in range(2, m // index + 1):
			if index * i >= m:
				break
			if nums[index] >= nums[index * i]:
				continue
			ret = max(ret, dfs(i * index))
		f[index] = ret + 1
		return f[index]
	ans = 0
	for i in range(1, m):
		ans = max(ans, dfs(i))
	return ans
n = read_integer()
for _ in range(n):
	print(func())


from collections import *
from math import *
from sys import *
input = stdin.readline
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [0] * n
	for i in range(1, n + 1):
		mx = 1
		for j in range(1, int(sqrt(i) + 1)):
			if i % j == 0:
				if a[j - 1] < a[i - 1]:
					mx = max(mx, b[j - 1] + 1)
				if a[i // j - 1] < a[i - 1]:
					mx = max(mx, b[i // j - 1] + 1)
		b[i - 1] = mx
	mx = max(b)
	stdout.write(str(mx) + '\n')


import math
t = int(input())
for _ in range(t):
	n = int(input())
	arr1 = list(map(int, input().split()))
	arr2 = [1] * n
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if arr1[i - 1] < arr1[j - 1]:
				arr2[j - 1] = max(arr2[j - 1], arr2[i - 1] + 1)
	print(max(arr2))


t = int(input())
for ii in range(t):
	n = int(input())
	models = list(map(int, input().split()))
	models.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(n // 2, 0, -1):
		j = 2
		while i * j <= n:
			if dp[j * i] + 1 > dp[i] and models[i] < models[j * i]:
				dp[i] = dp[j * i] + 1
			j += 1
	print(max(dp))


def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = len(li) - 1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def mex(li):
	check = [0] * 1001
	for i in li:
		check[i] += 1
	for i in range(len(check)):
		if check[i] == 0:
			return i

def sumdigits(n):
	ans = 0
	while n != 0:
		ans += n % 10
		n //= 10
	return ans

def product(li):
	ans = 1
	for i in li:
		ans *= i
	return ans

def maxpower(n, k):
	cnt = 0
	while n > 1:
		cnt += 1
		n //= k
	return cnt

def knapsack(li, sumi, s, n, dp):
	if s == sumi // 2:
		return 1
	elif n == 0:
		return 0
	elif dp[n][s] != -1:
		return dp[n][s]
	else:
		if li[n - 1] <= s:
			dp[n][s] = knapsack(li, sumi, s - li[n - 1], n - 1, dp) or knapsack(li, sumi, s, n - 1, dp)
		else:
			dp[n][s] = knapsack(li, sumi, s, n - 1, dp)
		return dp[n][s]

def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum
from math import *
from collections import deque
max_steps = 100005
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[j] > a[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


def solve(l):
	maxel = 1
	dyn = [1 for j in range(len(l))]
	dyn[0] = 1
	for el in range(0, len(l) // 2 + 1):
		for mult in range(2, len(l) // (el + 1) + 1):
			if l[el] < l[(el + 1) * mult - 1]:
				dyn[(el + 1) * mult - 1] = max(dyn[el] + 1, dyn[(el + 1) * mult - 1])
				maxel = max(maxel, dyn[(el + 1) * mult - 1])
	return maxel
t = int(input())
for i in range(t):
	n = int(input())
	l = [int(j) for j in input().split()]
	print(solve(l))


def answer(arr):
	n = len(arr)
	history = [0] * (n + 1)
	stack = [[1, 1, 0]]
	while len(stack) != 0:
		stack[-1][1] += 1
		a = stack[-1]
		b = a[0] * a[1]
		if b <= n:
			if arr[a[0] - 1] < arr[b - 1]:
				if history[b] is 0:
					stack.append([b, 1, 0])
				else:
					stack[-1][2] = max(stack[-1][2], history[b] + 1)
		else:
			p = stack.pop()
			if len(stack) > 0:
				stack[-1][2] = max(stack[-1][2], p[2] + 1)
				history[stack[-1][0]] = max(history[stack[-1][0]], stack[-1][2])
			if len(stack) == 0 and p[0] < n:
				stack = [[p[0] + 1, 1, 0]]
	return max(history) + 1
testCount = int(input())
for _ in range(testCount):
	n = int(input())
	arr = list(map(int, input().split()))
	print(answer(arr))


t = int(input())
ans = []
for a in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1 for j in range(n)]
	for i in range(n):
		k = i + 1
		for j in range(2 * k, n + 1, k):
			if s[j - 1] > s[i]:
				dp[j - 1] = max(dp[j - 1], dp[i] + 1)
	mx = 0
	for i in dp:
		mx = max(mx, i)
	ans.append(mx)
for p in ans:
	print(p)


def solve(n, seq, ansArr):
	maxValue = 0
	for index in range(n - 1, -1, -1):
		biggest = 0
		jump = index + 1
		startIndex = index
		while startIndex + jump < n:
			temp = 0
			startIndex += jump
			if seq[startIndex] > seq[index]:
				temp += ansArr[startIndex]
			if temp > biggest:
				biggest = temp
		biggest += 1
		ansArr[index] = biggest
		if biggest > maxValue:
			maxValue = biggest
	return maxValue
ansArr = [0] * 100001
for _ in range(int(input())):
	n = int(input())
	seq = list(map(int, input().split()))
	print(solve(n, seq, ansArr))


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	div = {i: [] for i in range(1, n + 1)}
	ans = [1 for i in range(n)]
	for i in range(1, n + 1):
		c = 0
		for k in div[i]:
			if a[k - 1] < a[i - 1]:
				c = max(c, ans[k - 1])
		ans[i - 1] += c
		t = 2 * i
		while t < n + 1:
			div[t].append(i)
			t += i
	print(max(ans))


for i in range(int(input())):
	n = int(input())
	s = input()
	s = '0 ' + s
	arr = list(map(int, s.split()))
	f = list((1 for j in range(n + 1)))
	for j in range(1, n + 1):
		for h in range(j * 2, n + 1, j):
			if arr[j] < arr[h]:
				f[h] = max(f[h], f[j] + 1)
	ans = 0
	for j in f:
		ans = max(ans, j)
	print(max(f))


t = int(input())

def factors(n):
	d = [1]
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			d.append(i)
			d.append(n // i)
	return d
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	dp = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		d = factors(i)
		for j in d:
			if arr[j - 1] < arr[i - 1]:
				dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))


num = int(input())
for _ in range(num):
	n = int(input())
	l = [int(i) for i in input().split()]
	f = [1 for i in range(n)]
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j - 1] > l[i - 1]:
				f[j - 1] = max(f[j - 1], f[i - 1] + 1)
	print(max(f))


import sys
input = sys.stdin.buffer.readline
MAXPRIME = 100000
isPrime = [0 for _ in range(MAXPRIME + 1)]
isPrime[0] = -1
isPrime[1] = -1
for i in range(2, MAXPRIME // 2):
	if isPrime[i] == 0:
		for multiple in range(i * i, MAXPRIME + 1, i):
			if isPrime[multiple] == 0:
				isPrime[multiple] = i

def getDivisors(x):
	originalx = x
	if x == 1:
		return []
	primeFactors = []
	while isPrime[x] != 0:
		primeFactors.append(isPrime[x])
		x //= isPrime[x]
	primeFactors.append(x)
	factors = {1}
	n = len(primeFactors)
	for i in range(2 ** n):
		num = 1
		for j in range(n):
			if i & 1 << j > 0:
				num *= primeFactors[j]
		factors.add(num)
	factors.remove(originalx)
	return list(factors)
t = int(input())
for _ in range(t):
	n = int(input())
	s = [int(x) for x in input().split()]
	s.insert(0, -1)
	dp = [1 for __ in range(n + 1)]
	ans = 1
	for i in range(2, n + 1):
		for prev in getDivisors(i):
			if s[prev] < s[i]:
				dp[i] = max(dp[i], 1 + dp[prev])
		ans = max(ans, dp[i])
	print(ans)


def mult_input():
	return map(int, input().split())

def list_input():
	return list(map(int, input().split()))
for nt in range(int(input())):
	n = int(input())
	l = list_input()
	if n == 1:
		print(1)
		continue
	ans = [1] * (n + 1)
	for i in range(1, n + 1):
		j = 2 * i
		while j <= n:
			if l[j - 1] > l[i - 1]:
				ans[j - 1] = max(ans[j - 1], ans[i - 1] + 1)
			j += i
	final = 0
	for i in ans:
		final = max(i, final)
	print(final)


from collections import defaultdict
from sys import stdin, stdout
for testcases in range(int(stdin.readline())):
	n = int(stdin.readline())
	arr = list(map(int, stdin.readline().split()))
	arr = [-1] + arr
	dict = defaultdict(int)
	dict[1] = 1
	ans = 1
	for i in range(2, n + 1):
		rec = 1
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0 and arr[i] > arr[j]:
				rec = max(dict[j] + 1, rec)
			if i % j == 0 and arr[i] > arr[i // j]:
				rec = max(dict[i // j] + 1, rec)
		dict[i] = rec
		ans = max(ans, dict[i])
	stdout.write(str(ans) + '\n')


import sys
input = sys.stdin.readline

def main():
	test = int(input())
	for _ in range(test):
		n = int(input())
		arr = [int(x) for x in input().split()]
		ans = 1
		dp = [1 for i in range(0, n + 1)]
		for idx in range(n, 0, -1):
			temp = 0
			for nxt in range(idx + idx, n + 1, idx):
				if arr[idx - 1] < arr[nxt - 1]:
					temp = max(temp, dp[nxt])
			dp[idx] = 1 + temp
			ans = max(ans, dp[idx])
		print(ans)
main()


import math

def factors(n):
	F = [1]
	if n % 2 == 0:
		F.append(2)
		F.append(n // 2)
	for i in range(3, math.ceil(math.sqrt(n)) + 3):
		if n % i == 0:
			F.append(i)
			F.append(n // i)
	return set(F)

def solution(A, n):
	best = 0
	dp = [1 for _ in range(n)]
	for i in range(1, n + 1):
		for f in factors(i):
			if A[i - 1] > A[f - 1]:
				dp[i - 1] = max(dp[i - 1], dp[f - 1] + 1)
		best = max(best, dp[i - 1])
	return best
t = int(input())
for _ in range(t):
	n = int(input())
	A = list(map(int, input().split(' ')))
	print(solution(A, n))


import sys
input = sys.stdin.readline
t = int(input())
for r in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l = [0] + l
	dp = [1] * (n + 1)
	for i in range(n, 0, -1):
		if i == n:
			continue
		temp = i
		counter = 2
		maxi = 0
		while temp * counter < n + 1:
			if temp * counter <= n and l[i] < l[temp * counter]:
				maxi = max(maxi, dp[temp * counter])
			counter += 1
		dp[i] += maxi
	print(max(dp))


for cas in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	ret = [1] * (n + 1)
	for i in range(1, n):
		j = i << 1
		while j <= n:
			if a[i - 1] < a[j - 1]:
				ret[j] = max(ret[j], ret[i] + 1)
			j += i
	print(max(ret))


from math import sqrt

def get_divisors(n):
	divs = set()
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			divs.add(i)
			divs.add(n // i)
	return list(divs)

def main() -> None:
	for _ in range(int(input())):
		n = int(input())
		A = [int(a) for a in input().split()]
		dp = [1] * n
		for i in range(1, n + 1):
			for j in get_divisors(i):
				if A[j - 1] < A[i - 1]:
					dp[i - 1] = max(dp[i - 1], dp[j - 1] + 1)
		print(max(dp))
main()


for i in range(int(input())):
	n = int(input())
	A = input().split(' ')
	S = [0]
	for j in range(n):
		S.append(int(A[j]))
	L = [1] * (n + 1)
	for j in range(1, n // 2 + 1):
		for k in range(1, n // j + 1):
			if S[j] < S[j * k]:
				L[j * k] = max(L[j] + 1, L[j * k])
	print(max(L))


from sys import stdin
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, stdin.readline().split()))
	d = [1] * (n + 1)
	l.insert(0, 0)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if l[j] > l[i]:
				d[j] = max(d[j], d[i] + 1)
	print(max(d))


import math

def printDivisors(n):
	v = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				v.append(i)
			else:
				v.append(i)
				v.append(n // i)
		i = i + 1
	return v
for _ in range(int(input())):
	n = int(input())
	a = [int(o) for o in input().split()]
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		k = printDivisors(i)
		for j in k:
			if a[j - 1] < a[i - 1]:
				dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))


import math
import collections
from sys import stdin, stdout
T = int(stdin.readline())
for _ in range(T):
	n = int(stdin.readline())
	s = [0] + list(map(int, stdin.readline().split()))
	exp = {}
	p = [1] * (n + 1)
	for i in range(n // 2 + 1, 0, -1):
		j = 2
		tmp = 1
		while i * j <= n:
			if s[i * j] > s[i]:
				if tmp < p[i * j] + p[i]:
					tmp = p[i * j] + p[i]
			j += 1
		p[i] = tmp
	print(max(p))


import sys
from math import sqrt, floor, factorial, gcd
inp = sys.stdin.readline
read = lambda : list(map(int, inp().strip().split()))

def min_div(n):
	for i in range(2, int(sqrt(n)) + 1):
		if n % i == 0:
			return i
	return n

def lcm(a, b):
	return a * b // gcd(a, b)

def a():
	ans = ''
	for _ in range(int(inp())):
		(n, k) = read()
		md = min_div(n)
		while md != 2:
			n += md
			md = min_div(n)
			k -= 1
		n += k * 2
		ans += str(n) + '\n'
	print(ans)

def b():
	ans = ''
	for _ in range(int(inp())):
		n = int(inp())
		arr = [0] + read()
		dp = [1 for i in range(n + 1)]
		max_ans = 1
		for i in range(n, 0, -1):
			j = 2
			while i * j <= n:
				if arr[i] < arr[i * j]:
					dp[i] = max(dp[i], 1 + dp[i * j])
					max_ans = max(max_ans, dp[i])
				j += 1
		ans += str(max_ans) + '\n'
	print(ans)

def c():
	n = int(inp())
	arr = read()
	tem = lcm(arr[0], arr[1])
	for i in range(n):
		for j in range(i + 1, n):
			tem = gcd(tem, lcm(arr[i], arr[j]))
	print(tem)
b()


import functools
import math

@functools.lru_cache(maxsize=None)
def divisors(i):
	divs = set()
	for div in range(1, math.ceil(math.sqrt(i)) + 1):
		if i % div == 0:
			divs.add(div)
			divs.add(i // div)
	return sorted(divs)

def solve(n, S):
	dp = [1] * n
	for i in range(1, n + 1):
		for div in divisors(i):
			if S[div - 1] < S[i - 1]:
				dp[i - 1] = max(dp[i - 1], dp[div - 1] + 1)
	return max(dp)

def main():
	T = int(input())
	for _ in range(T):
		n = int(input())
		S = list(map(int, input().split()))
		print(solve(n, S))
main()


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
for _ in range(int(data())):
	n = int(data())
	arr = l()
	dp = dd(lambda : 1)
	dp[-1] = 1
	for i in range(1, n + 1):
		j = i
		while j <= n:
			if arr[i - 1] < arr[j - 1]:
				dp[j] = max(dp[i] + 1, dp[j])
			j += i
	out(max(dp.values()))


def F(N, M):
	dp = [1 for i in range(N + 1)]
	for i in range(1, N + 1):
		for j in range(i * 2, N + 1, i):
			if M[j] > M[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)
Z = int(input())
O = []
for i in range(Z):
	O.append(F(int(input()), [0] + list(map(int, input().split()))))
print(*O, sep='\n')


import sys
input = sys.stdin.readline
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
t = int(input())
for i in range(t):
	n = int(input())
	s = [int(i) for i in input().split() if i != '\n']
	dp = [0] * (n + 1)
	dp[1] = 1
	for j in range(2, n + 1):
		fact = factors(j)
		maxa = 1
		for k in fact:
			if s[k - 1] < s[j - 1]:
				maxa = max(maxa, dp[k] + 1)
		dp[j] = maxa
	print(max(dp))


t = int(input())
for case in range(t):
	n = int(input())
	models = [int(x) for x in input().split()]
	models = [0] + models
	answer = (n + 1) * [1]
	for i in range(1, n):
		maximum = n // i
		for j in range(1, maximum + 1):
			if models[i * j] > models[i]:
				answer[i * j] = max(answer[i] + 1, answer[i * j])
	print(max(answer))


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	dp = [1] * n
	for i in range(2, n + 1):
		s = factors(i)
		s.remove(1)
		x = 0
		for j in s:
			if l[i - 1] > l[i // j - 1]:
				if dp[i // j - 1] > x:
					x = dp[i // j - 1]
		dp[i - 1] = dp[i - 1] + x
	print(max(dp))


from sys import stdin

def solve(n, s):
	s = [0] + s
	v = [1] * (n + 1)
	for p in range(n, 0, -1):
		m = 0
		for k in range(2 * p, n + 1, p):
			if s[p] < s[k]:
				m = max(m, v[k])
		v[p] += m
	ans = 1
	for i in v:
		ans = max(ans, i)
	print(ans)
	return

def main():
	inp = stdin.readline
	for _ in range(int(inp())):
		n = int(inp())
		s = list(map(int, inp().split()))
		solve(n, s)
main()


t = int(input())
for i in range(t):
	n = int(input())
	si = list(map(int, input().split()))
	ans = [1] * n
	for i in range(n):
		i2 = i + 1
		for j in range(i + i2, n, i2):
			if si[i] < si[j]:
				ans[j] = max(ans[i] + 1, ans[j])
	print(max(ans))


import math
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	arr = [0] * (n + 1)
	arr[1] = 1
	for i in range(1, n + 1):
		for k in range(2, n // i + 1):
			o1 = 0
			o2 = 0
			if a[k * i - 1] > a[i - 1]:
				o1 = arr[i]
			arr[k * i] = max(arr[k * i], o1 + 1)
	print(max(arr))


for _ in [0] * int(input()):
	n = int(input())
	s = list(map(int, input().split()))
	max_len = [1] * n
	for i in range(n):
		mul = 2 * (i + 1)
		while mul <= n:
			if s[mul - 1] > s[i]:
				max_len[mul - 1] = max(max_len[mul - 1], max_len[i] + 1)
			mul += i + 1
	print(max(max_len))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l = [0] + l
	p = [0] + [1] * n
	for x in range(1, n + 1):
		for y in range(2 * x, n + 1, x):
			if l[x] < l[y]:
				p[y] = max(p[y], p[x] + 1)
	print(max(p))


import math
from sys import stdin

def divisors(n):
	c = int(math.sqrt(n)) + 1
	yield 1
	for i in range(2, c):
		if n % i == 0:
			yield i
			if i != n // i:
				yield (n // i)

def solution2():
	input = stdin.readline
	t = int(input())
	for i in range(t):
		n = int(input())
		arr = [int(x) for x in input().split()]
		dp = [0] * n
		dp[0] = 1
		for i in range(1, n):
			t = 0
			for j in divisors(i + 1):
				if dp[j - 1] > t and arr[j - 1] < arr[i]:
					t = dp[j - 1]
			dp[i] = t + 1
		print(max(dp))
solution2()


for f in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	poss = [1] * (n + 1)
	for i in range(1, n):
		j = 2
		while j * i <= n:
			if s[j * i - 1] > s[i - 1]:
				poss[i * j] = max(poss[i * j], poss[i] + 1)
			j += 1
	print(max(poss))


import sys
ints = (int(x) for x in sys.stdin.read().split())
sys.setrecursionlimit(3000)

def main():
	ntc = next(ints)
	for tc in range(1, ntc + 1):
		n = next(ints)
		s = [next(ints) for i in range(n)]
		f = [0] * n
		for i in range(n, 0, -1):
			fi = 0
			j = 2 * i
			while j <= n:
				if s[i - 1] < s[j - 1]:
					fi = max(fi, f[j - 1])
				j += i
			f[i - 1] = 1 + fi
		ans = max(f)
		print(ans)
	return
main()


ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda : int(input())
ip = lambda : [int(w) for w in input().split()]
for _ in range(inp()):
	n = inp()
	x = ip()
	x.insert(0, 0)
	dp = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		k = i * 2
		for j in range(k, n + 1, i):
			if x[j] > x[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


import math
from collections import Counter, deque
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
IN = lambda : input()
mod = 10 ** 9 + 7

def s(a):
	print(' '.join(list(map(str, a))))
for i in range(I()):
	n = I()
	a = L()
	l = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if a[i - 1] < a[j - 1]:
				l[j] = max(l[j], l[i] + 1)
	print(max(l))


for _ in range(int(input())):
	n = int(input())
	A = list(map(int, input().split()))
	ind = [1] * (n + 1)
	for i in range(1, n):
		j = 2
		while j * i <= n:
			if A[j * i - 1] > A[i - 1]:
				ind[i * j] = max(ind[i * j], ind[i] + 1)
			j += 1
	print(max(ind))


import math
from sys import stdin

def divisors(n):
	c = int(math.sqrt(n)) + 1
	ss = {1}
	for i in range(2, c):
		if n % i == 0:
			ss.add(i)
			ss.add(n // i)
	return ss

def solution2():
	input = stdin.readline
	t = int(input())
	for i in range(t):
		n = int(input())
		arr = [int(x) for x in input().split()]
		dp = [0] * n
		dp[0] = 1
		for i in range(1, n):
			t = 0
			for v in divisors(i + 1):
				if dp[v - 1] > t and arr[v - 1] < arr[i]:
					t = dp[v - 1]
			dp[i] = t + 1
		print(max(dp))
solution2()


(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, dgraphs, mod) = (lambda : sorted(zz()), {}, 10 ** 9 + 7)
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = int(z())
for _ in range(num):
	n = int(z())
	l = zz()
	bea = [1] * n
	for i in range(n):
		for j in range(2 * i + 1, n, i + 1):
			if l[j] > l[i]:
				bea[j] = max(bea[i] + 1, bea[j])
	print(max(bea))


list_ans = []
for _ in range(int(input())):
	n = int(input())
	list1 = list(map(int, input().split()))
	list2 = [1] * n
	for i in range(0, n):
		for j in range(2 * i + 1, n, i + 1):
			if list1[j] > list1[i]:
				list2[j] = max(list2[j], list2[i] + 1)
	list_ans.append(max(list2))
print(*list_ans, sep='\n')


for _ in range(int(input())):
	n = int(input())
	inp = [0] + [int(x) for x in input().split()]
	dp = {x: 1 for x in range(n + 1)}
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if inp[j] > inp[i]:
				dp[j] = max(dp[i] + 1, dp[j])
	print(max(dp.values()))


def max_models(weights):
	cache = {i: 1 for i in range(1, len(weights) + 1)}
	for i in range(1, len(weights) + 1):
		for j in range(i * 2, len(weights) + 1, i):
			if weights[j - 1] > weights[i - 1]:
				cache[j] = max(cache[j], cache[i] + 1)
	return max(cache.values())
results = []
for _ in range(int(input())):
	_ = input()
	weights = [int(el) for el in input().split()]
	results.append(str(max_models(weights)))
print('\n'.join(results))


from math import sqrt
t = int(input())
out = ''
while t > 0:
	t -= 1
	n = int(input())
	a = [int(i) for i in input().split(' ')]
	answer = 1
	dp = [1] * (n + 1)
	dp[0] = 1
	dp[1] = 1
	for i in range(2, n + 1):
		j = 1
		while j * j <= i:
			divs = [j]
			x = i // j
			if x != j:
				divs.append(x)
			for div in divs:
				if i % div == 0 and a[div - 1] < a[i - 1]:
					dp[i] = max(dp[i], dp[div] + 1)
			j += 1
	out += f'{max(dp)}\n'
print(out)


t = int(input())
for ii in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	dp = [1] * n
	curpr = []
	for i in range(1, n + 1):
		ind = i - 1
		j = 2
		while j * i - 1 < n:
			if a[j * i - 1] > a[ind]:
				dp[j * i - 1] = max(dp[j * i - 1], dp[ind] + 1)
			j += 1
	print(max(dp))


def inp():
	return int(input())

def insr():
	s = input()
	return s

def inlt():
	return list(map(int, input().split()))

def solve(inpl):
	dp = [1] * len(inpl)
	m = 0
	for i in range(1, len(inpl)):
		k = 2
		while i * k < len(inpl):
			if inpl[i * k] > inpl[i]:
				dp[i * k] = max(dp[i * k], dp[i] + 1)
			k += 1
	return max(dp)
r = inp()
for i in range(r):
	size = inp()
	inpl = inlt()
	print(solve([0] + inpl))


from math import sqrt
from collections import defaultdict as dd
import sys
input = sys.stdin.readline
import bisect
nn = 100005
prime = [True for i in range(nn + 1)]
p = 2
d = dd(lambda : [1])
while p * p <= nn:
	if prime[p] == True:
		for i in range(p, nn + 1, p):
			d[i].append(p)
	p += 1
prime[1] = False
prime[0] = False
t = int(input())
while t:
	n = int(input())
	l = list(map(int, input().split()))
	val = [1] * n
	for i in range(1, n + 1):
		for j in d[i]:
			ii = i // j
			if l[ii - 1] < l[i - 1]:
				val[i - 1] = max(val[i - 1], val[ii - 1] + 1)
	print(max(val))
	t -= 1


from collections import defaultdict
l = len
for _ in range(int(input())):
	n = int(input())
	x = defaultdict(int)
	m = [0] + [int(i) for i in input().split()]
	for i in range(1, n + 1, +1):
		for j in range(i * 2, n + 1, +i):
			if m[i] < m[j]:
				if i not in x:
					if j in x:
						x[j] = max(2, x[j])
					else:
						x[j] = 2
				elif j in x:
					x[j] = max(x[i] + 1, x[j])
				else:
					x[j] = x[i] + 1
	if l(x.values()) == 0:
		print(1)
		continue
	print(max(x.values()))


import math
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l = [0] + l
	arr = [1] * (n + 1)
	ans = 1
	for i in range(1, n + 1):
		for j in range(1, int(math.sqrt(i)) + 1):
			if i % j == 0:
				d1 = j
				d2 = int(i / j)
				if l[i] > l[d1]:
					arr[i] = max(arr[i], arr[d1] + 1)
				if l[i] > l[d2]:
					arr[i] = max(arr[i], arr[d2] + 1)
		ans = max(ans, arr[i])
	print(ans)


import sys
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	arr = [0] + arr
	cnt = [1] * (n + 1)
	f_max = -sys.maxsize - 1
	for i in range(2, n + 1):
		maxi = -sys.maxsize - 1
		for j in range(1, int(i ** 0.5) + 1):
			if i % j == 0:
				if arr[i] > arr[j] and maxi < cnt[j] + 1:
					cnt[i] = cnt[j] + 1
					maxi = cnt[i]
				if arr[i] > arr[i // j] and maxi < cnt[i // j] + 1:
					cnt[i] = cnt[i // j] + 1
					maxi = cnt[i]
		f_max = max(f_max, maxi)
	if f_max < 1:
		print(1)
	else:
		print(f_max)


from sys import stdin
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
for _ in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	f = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[i - 1] < s[j - 1]:
				f[j] = max(f[j], f[i] + 1)
	print(max(f))


t = int(input())
for i in range(t):
	n = int(input())
	l1 = list(map(int, input().split()))
	l2 = [0] + l1
	l3 = [1] * (n + 1)
	for j in range(1, n + 1):
		for k in range(j * 2, n + 1, j):
			if l2[j] < l2[k]:
				l3[k] = max(l3[k], l3[j] + 1)
	y = l3[1]
	for j in range(2, n + 1):
		if y < l3[j]:
			y = l3[j]
	print(y)


def dfs(index, divisor, count, s):
	best = count
	for i in range(index + divisor, len(s) + 1, divisor):
		if s[i - 1] > s[index - 1]:
			best = max(best, dfs(i, i, count + 1, s))
	return best

def task(n, s):
	best = 0
	for index in range(1, n + 1):
		best = max(best, dfs(index, index, 1, s))
	print(best)
t = int(input())
for i in range(0, t):
	n = int(input())
	s = list(map(int, input().split()))
	task(n, s)


class SegmentTree:

	def __init__(self, data, default=0, func=lambda a, b: gcd(a, b)):
		self._default = default
		self._func = func
		self._len = len(data)
		self._size = _size = 1 << (self._len - 1).bit_length()
		self.data = [default] * (2 * _size)
		self.data[_size:_size + self._len] = data
		for i in reversed(range(_size)):
			self.data[i] = func(self.data[i + i], self.data[i + i + 1])

	def __delitem__(self, idx):
		self[idx] = self._default

	def __getitem__(self, idx):
		return self.data[idx + self._size]

	def __setitem__(self, idx, value):
		idx += self._size
		self.data[idx] = value
		idx >>= 1
		while idx:
			self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
			idx >>= 1

	def __len__(self):
		return self._len

	def query(self, start, stop):
		if start == stop:
			return self.__getitem__(start)
		stop += 1
		start += self._size
		stop += self._size
		res = self._default
		while start < stop:
			if start & 1:
				res = self._func(res, self.data[start])
				start += 1
			if stop & 1:
				stop -= 1
				res = self._func(res, self.data[stop])
			start >>= 1
			stop >>= 1
		return res

	def __repr__(self):
		return 'SegmentTree({0})'.format(self.data)
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from bisect import bisect_right, bisect_left
from fractions import Fraction

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans
from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	total = [1] * n
	for i in range(n - 1, -1, -1):
		for j in range(2 * i + 1, n, i + 1):
			if a[j] > a[i]:
				total[i] = max(total[i], total[j] + 1)
	print(max(total))


t = int(input())

def make_divisors(n):
	divisors = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			divisors.append(i)
			if i != n // i:
				divisors.append(n // i)
	return divisors
ans = [0] * t
for i in range(t):
	n = int(input())
	V = [1] * n
	s = list(map(int, input().split()))
	for j in range(1, n + 1):
		tempV = make_divisors(j)
		for k in tempV:
			if s[k - 1] < s[j - 1]:
				V[j - 1] = max(V[k - 1] + 1, V[j - 1])
	ans[i] = max(V)
for i in range(t):
	print(ans[i])


q = int(input())
while q > 0:
	q -= 1
	n = int(input())
	a = list(map(int, input().split()))
	a.insert(0, 0)
	dp = [1] * (n + 5)
	res = 1
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if a[i] < a[j]:
				dp[j] = max(dp[i] + 1, dp[j])
		res = max(res, dp[i])
	print(res)


import math

def divisors(x):
	div = []
	i = 1
	while i <= math.sqrt(x):
		if x % i == 0:
			if x // i == i:
				div.append(i)
			else:
				div.append(i)
				div.append(x // i)
		i += 1
	return div
T = int(input())
for _ in range(T):
	n = int(input())
	a = list(map(int, input().split()))
	f = [1] * n
	ans = 1
	for i in range(n):
		for d in divisors(i + 1):
			j = d - 1
			if a[j] < a[i]:
				f[i] = max(f[i], f[j] + 1)
		ans = max(ans, f[i])
	print(ans)


t = int(input())

def sol(index):
	if index > n:
		return 0
	if dp[index] != -1:
		return dp[index]
	count = 0
	for i in range(2 * index, n + 1, index):
		if arr[i] > arr[index]:
			count = max(count, 1 + sol(i))
	dp[index] = count
	return count
for testcase in range(1, t + 1):
	n = int(input())
	arr = list(map(int, input().split()))
	arr = [0] + arr
	ans = 0
	dp = [-1 for i in range(n + 1)]
	for i in range(1, n + 1):
		ans = max(ans, 1 + sol(i))
	print(ans)


t = int(input())
for i in range(t):
	n = int(input())
	models = list(map(int, input().split()))
	arr = [1] * n
	for i in range(n // 2, 0, -1):
		for j in range(2, n // i + 1):
			if models[i - 1] < models[i * j - 1]:
				arr[i - 1] = max(arr[i - 1], arr[i * j - 1] + 1)
	print(max(arr))


import sys
from math import inf
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	s = [0] + list(map(int, input().split()))
	dp = [1] * (n + 1)
	for i in range(1, n):
		j = 2
		while i * j <= n:
			if s[i * j] > s[i]:
				dp[i * j] = max(dp[i * j], dp[i] + 1)
			j += 1
	print(max(dp))


import math
for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a = [0] + a
	if n == 1:
		print(1)
	else:
		dp = [1] * (n + 1)
		for i in range(2, n + 1):
			maxi = -10 ** 18
			for j in range(1, int(i ** 0.5) + 1):
				if i % j == 0:
					if i // j == j:
						if a[j] < a[i]:
							dp[i] = max(dp[i], 1 + dp[j])
					else:
						if a[j] < a[i]:
							dp[i] = max(dp[i], 1 + dp[j])
						if a[i // j] < a[i]:
							dp[i] = max(dp[i], 1 + dp[i // j])
		dp.sort()
		print(dp[-1])


for test in range(int(input())):
	n = int(input())
	l = list(map(int, input().strip().split(' ')))
	dp = [1] * len(l)
	ans = 1
	for i in range(1, len(l)):
		j = 2 * i
		while j <= len(l):
			if l[i - 1] < l[j - 1]:
				dp[j - 1] = max(dp[i - 1] + 1, dp[j - 1])
			j += i
		if dp[i] > ans:
			ans = dp[i]
	print(ans)


tc = int(input().strip())

def solve():
	n = int(input().strip())
	data = list(map(int, input().strip().split()))
	lengths = [1 for i in range(n)]
	for (i, n) in enumerate(data):
		r = lengths[i]
		for j in range(2 * i + 1, len(data), i + 1):
			if data[j] > n:
				lengths[j] = max(lengths[j], r + 1)
	print(max(lengths))
for t in range(tc):
	solve()


from collections import deque
from collections import OrderedDict
import math
import sys
import os
from io import BytesIO
import threading
import bisect
import heapq
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
input = sys.stdin.readline
ara = [0] * 100005
listOdd = list()

def aratosfen():
	global ara
	for i in range(2, int(math.sqrt(len(ara)))):
		if ara[i] == 0:
			for j in range(i * 2, len(ara), i):
				ara[j] = 1
	global listOdd
	for i in range(2, len(ara)):
		if ara[i] == 0:
			listOdd.append(i)
for t in range(int(input())):
	n = int(input())
	sAr = [0] + list(map(int, input().split()))
	dp = [1] * 100005
	for i in range(1, n + 1):
		for j in range(1, n + 1):
			if i * j > n:
				break
			elif sAr[i] < sAr[i * j]:
				dp[i * j] = max(dp[i] + 1, dp[i * j])
	answer = 0
	for i in range(1, n + 1):
		answer = max(dp[i], answer)
	print(answer)


for _ in range(int(input())):
	n = int(input())
	s = [0] + list(map(int, input().split()))
	l = [1] * (n + 1)
	for ima in range(1, n):
		t = 1
		while ima * (t + 1) <= n:
			t += 1
			if s[ima] < s[ima * t]:
				l[ima * t] = max(l[ima * t], l[ima] + 1)
	print(max(l))


import sys
import math

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
for t in range(int(input())):
	n = int(input())
	arr = get_list()
	ans = [0] * n
	for i in range(n):
		multi = 2
		ans[n - i - 1] = 1
		while (n - i) * multi - 1 < n:
			if arr[n - i - 1] < arr[(n - i) * multi - 1]:
				ans[n - i - 1] = max(ans[n - i - 1], 1 + ans[(n - i) * multi - 1])
			multi += 1
	print(max(ans))


T = int(input())
for i in range(T):
	n = int(input())
	l = list(map(int, input().split()))
	ans = [1] * n
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if l[j - 1] > l[i - 1]:
				ans[j - 1] = max(ans[i - 1] + 1, ans[j - 1])
	print(max(ans))


t = int(input())
for i in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	lens = [1] * n
	preds = [[] for j in range(n)]
	for j in range(1, n // 2 + 1):
		sj = s[j - 1]

		def filter_(k):
			return s[k - 1] > sj
		for k in filter(filter_, range(2 * j, n + 1, j)):
			preds[k - 1].append(j)
	for (j, preds_) in zip(range(n - 1, -1, -1), reversed(preds)):
		for k in preds_:
			lens[k - 1] = max(lens[k - 1], lens[j] + 1)
	print(max(lens))


import collections
from math import sqrt
import time

def solve(n, arr):
	dp = [1 for _ in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if arr[i] < arr[j]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)
t = int(input().strip())
for i in range(t):
	n = int(input().strip())
	arr = [0] + list(map(int, input().strip().split()))
	start_time = time.time()
	print(solve(n, arr))


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	N = int(input())
	a = list(map(int, input().split()))
	res = 0
	ok = [[] for _ in range(N)]
	for i in range(N - 1, -1, -1):
		for j in range(i, N, i + 1):
			if i == j:
				continue
			if a[i] < a[j]:
				ok[i].append(j)
	dp = [1] * N
	for i in range(N - 1, -1, -1):
		for j in ok[i]:
			dp[i] = max(dp[i], dp[j] + 1)
	print(max(dp))


import math

def pd(n):
	l = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n / i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
		i = i + 1
	return l
t = int(input())
for _ in range(t):
	n = int(input())
	ar = list(map(int, input().split()))
	ar.insert(0, 0)
	lis = [1 for i in range(n)]
	lis.insert(0, 0)
	for i in range(1, n + 1):
		lt = pd(i)
		for l in lt:
			if lis[l] + 1 > lis[i] and ar[i] > ar[l]:
				lis[i] = lis[l] + 1
	print(max(lis))


def find_factors(n):
	i = 2
	ans = [1]
	while i * i <= n:
		if n % i == 0:
			ans.append(i)
			if i != n // i:
				ans.append(n // i)
		i += 1
	ans.sort()
	return ans
t = int(input())
for _ in range(t):
	n = int(input())
	values = [0]
	sizes = list(map(int, input().split()))
	values += sizes
	del sizes
	answers = [1] * (n + 2)
	for i in range(1, n + 1):
		factors = find_factors(i)
		max_v = 1
		for j in factors:
			ans = 0
			if values[i] > values[j]:
				ans = answers[j] + 1
			max_v = max(max_v, ans)
		answers[i] = max_v
	print(max(answers))


from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(input())
for _ in range(gete(int)):
	n = gete(int)
	s = geta(int)
	nums = [1] * (n + 1)
	ans = 0
	for i in range(n, 0, -1):
		for j in range(2 * i, n + 1, i):
			if s[i - 1] < s[j - 1] and nums[i] <= nums[j] + 1:
				nums[i] = nums[j] + 1
		if ans < nums[i]:
			ans = nums[i]
	print(ans)


from sys import stdin, stdout
import heapq
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
import sys

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))

def solve():
	n = get_int()
	ls = get_list()
	dp = [1 for _ in range(n + 1)]
	for i in range(1, n + 1):
		for j in range(i, n + 1, i):
			if ls[j - 1] > ls[i - 1]:
				dp[j] = max(dp[j], dp[i] + 1)
	return max(dp)

def main():
	ans = solve()
	print(ans)
TestCases = True
if TestCases:
	for i in range(get_int()):
		main()
else:
	main()


import heapq
t = int(input())
for _ in range(t):
	n = int(input())
	sizes = [int(g) for g in input().split(' ')]
	max_count = 1
	vals = [0 for _ in range(n)]
	vals[0] = 1
	for i in range(1, n + 1):
		current_pos = i
		index = i - 1
		vals[index] = max(vals[index], 1)
		current_pos *= 2
		if current_pos <= n and sizes[current_pos - 1] > sizes[index]:
			vals[current_pos - 1] = max(vals[current_pos - 1], vals[index] + 1)
		while current_pos + index + 1 <= n:
			current_pos += index + 1
			if sizes[current_pos - 1] > sizes[index]:
				vals[current_pos - 1] = max(vals[current_pos - 1], vals[index] + 1)
	print(max(vals))


import math

def get_divisors(n):
	i = 1
	divisors = []
	while i <= math.sqrt(n):
		if n % i == 0:
			divisors.append(i)
			if n // i != i:
				divisors.append(n // i)
		i += 1
	divisors.sort()
	return divisors
t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	dp = [1 for _ in range(n)]
	for i in range(1, n):
		divisors = get_divisors(i + 1)
		for d in divisors:
			if s[i] > s[d - 1] and dp[d - 1] + 1 > dp[i]:
				dp[i] = dp[d - 1] + 1
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	i_row = [0]
	for cell in input().split():
		i_row.append(int(cell))
	f = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if i_row[j] > i_row[i]:
				f[j] = max(f[j], f[i] + 1)
	print(max(f))


for t in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	length = [1] * n
	for i in range(n - 1, -1, -1):
		no = i + i + 1
		maxi = length[i]
		while no < n:
			if arr[no] > arr[i]:
				if length[i] + length[no] > maxi:
					maxi = length[i] + length[no]
			no += i + 1
		length[i] = maxi
	maxi = 0
	for i in range(n):
		if length[i] > maxi:
			maxi = length[i]
	print(maxi)


from sys import stdin, gettrace
if not gettrace():

	def input():
		return next(stdin)[:-1]

def main():

	def solve():
		n = int(input())
		ss = [0] + [int(a) for a in input().split()]
		length = [1] * (n + 1)
		for i in range(1, n + 1):
			for j in range(i * 2, n + 1, i):
				if ss[j] > ss[i]:
					length[j] = max(length[j], length[i] + 1)
		print(max(length))
	q = int(input())
	for _ in range(q):
		solve()
main()


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
cases = int(input())
for t in range(cases):
	n = int(input())
	s = list(map(int, input().split()))
	d = {i + 1: 1 for i in range(n)}
	for i in range(1, n + 1):
		for j in range(i * 2, n + 1, i):
			if s[j - 1] > s[i - 1]:
				d[j] = max(d[j], d[i] + 1)
	print(max(d.values()))


from math import sqrt

def divs(n):
	a = []
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			if n // i == i:
				a.append(i)
			else:
				a += [i, n // i]
	return sorted(a)[1:]
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	dp = [1 for i in range(n)]
	for i in range(2, n + 1):
		divisors = divs(i)
		a = []
		for d in divisors:
			x = i // d
			a.append([arr[x - 1], dp[x - 1]])
		a.sort(key=lambda x: x[1], reverse=True)
		for el in a:
			(size, endl) = el
			if arr[i - 1] > size:
				dp[i - 1] += endl
				break
	print(max(dp))


from collections import defaultdict
a = int(input())
for i in range(a):
	al = defaultdict(int)
	n = int(input())
	z = list(map(int, input().split()))
	ans = []
	for i in range(len(z)):
		ans.append([z[i], i + 1])
	ans.sort()
	dl = defaultdict(int)
	for i in range(len(ans)):
		al[ans[i][1]] = i + 1
		dl[ans[i][1]] = ans[i][0]
	dp = [0 for i in range(len(ans) + 1)]
	for i in range(len(ans)):
		if dp[ans[i][1]] == 0:
			dp[ans[i][1]] = 1
		ini = 2
		while ans[i][1] * ini <= len(z):
			if dp[ans[i][1]] * ini == 0:
				if al[ans[i][1] * ini] > i and dl[ans[i][1] * ini] > dl[ans[i][1]]:
					dp[ans[i][1] * ini] = 2
				else:
					dp[ans[i][1] * ini] = 1
			elif al[ans[i][1] * ini] > i:
				if dl[ans[i][1] * ini] > dl[ans[i][1]]:
					dp[ans[i][1] * ini] = max(dp[ans[i][1] * ini], dp[ans[i][1]] + 1)
			ini += 1
	print(max(dp))


def prime_factorize(n):
	(i, j) = (2, [1])
	while i * i <= n:
		if n % i == 0:
			j.append(i)
			j.append(n // i)
		i = i + 1
	if n > 1:
		j.append(int(n))
	return j

def solve(arr, n):
	brr = [1]
	for i in range(1, n):
		(flag, max1) = (False, 1)
		crr = prime_factorize(i + 1)
		for j in crr:
			if arr[j - 1] < arr[i]:
				max1 = max(max1, brr[j - 1] + 1)
		brr.append(max1)
	print(max(brr))
	pass
test = 1
test = int(input())
for t in range(0, test):
	n = int(input())
	arr = [int(x) for x in input().split()]
	solve(arr, n)


from sys import stdin
from math import ceil, gcd
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	arr = list(map(int, stdin.readline().split()))
	dp = [1] * n
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if arr[j - 1] > arr[i - 1]:
				dp[j - 1] = max(dp[j - 1], 1 + dp[i - 1])
	print(max(dp))


t = int(input())
for _ in range(t):
	n = int(input())
	arr = [0] + list(map(int, input().rstrip().split()))
	dp = [1] * (n + 1)
	maxAns = float('-inf')
	for i in range(1, n + 1):
		for j in range(i + i, n + 1, i):
			if arr[j] > arr[i]:
				dp[j] = max(dp[j], dp[i] + 1)
		maxAns = max(maxAns, dp[i])
	print(maxAns)


t = int(input())
for _ in range(t):
	n = int(input())
	a = [0] + list(map(int, input().split()))
	dp = [0] * (n + 1)
	for i in range(n, 0, -1):
		m = 0
		idx = i * 2
		while idx <= n:
			if a[idx] > a[i]:
				m = max(m, dp[idx])
			idx += i
		dp[i] = m + 1
	print(max(dp))


from sys import stdin

def fun(i, s, n):
	k = s[i]
	if u[i]:
		return save[i]
	maxx = 0
	for j in range(2 * i, n + 1, i):
		if s[j] > k:
			g = fun(j, s, n)
			(u[j], save[j]) = (True, g)
			if g > maxx:
				maxx = g
	return 1 + maxx
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	s = [0] + list(map(int, stdin.readline().split()))
	save = [0 for i in range(n + 1)]
	u = [False for i in range(n + 1)]
	maxx = 0
	for i in range(1, n + 1):
		g = fun(i, s, n)
		if g > maxx:
			maxx = g
	print(max(maxx, 1))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	l = [0] + l
	f = [1] * (n + 1)
	p = 1
	while p <= n // 2:
		j = p
		while j <= n:
			if l[p] < l[j]:
				f[j] = max(f[j], f[p] + 1)
			j += p
		p += 1
	print(max(f))


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l2 = [1] * (n + 1)
	l1 = [0] + l
	l2 = [1] * (n + 1)
	i = n // 2
	while i > 0:
		j = 2
		while i * j <= n:
			if l2[j * i] + 1 > l2[i] and l1[i] < l1[j * i]:
				l2[i] = l2[i * j] + 1
			j = j + 1
		i = i - 1
	print(max(l2))


T = int(input())
while T != 0:
	n = int(input())
	nums = list(map(int, input().split()))
	nums.insert(0, 0)
	index = [1] * (n + 1)
	for i in range(1, n):
		j = i * 2
		while j <= n:
			if nums[i] < nums[j]:
				index[j] = max(index[j], index[i] + 1)
			j += i
	print(max(index))
	T -= 1


import math
import sys

def divisors(n):
	a = []
	i = 1
	while i <= int(math.sqrt(n)):
		if n % i == 0:
			if n // i == i:
				a.append(i)
			else:
				a.append(i)
				a.append(n // i)
		i += 1
	a.sort()
	a = a[0:len(a) - 1]
	return a
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(input())
	l = list(map(int, sys.stdin.readline().split()))
	arr = [1] * (n + 1)
	for i in range(1, n):
		a = divisors(i + 1)
		cur = 1
		for j in a:
			if l[j - 1] < l[i]:
				cur = max(arr[j - 1] + 1, cur)
		arr[i] = cur
	ans = max(arr)
	print(ans)


for T in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	d = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2, n // i + 1):
			if s[i - 1] < s[i * j - 1]:
				d[i * j] = max(d[i * j], d[i] + 1)
	print(max(d))


q = int(input())
for _ in range(q):
	n = int(input())
	A = list(map(int, input().split(' ')))
	dp = [None for i in range(n + 1)]

	def FOO(prev):
		if dp[prev] != None:
			return dp[prev]
		else:
			size = A[prev - 1]
			MAX = 1
			for i in range(2 * prev, n + 1, prev):
				if i % prev == 0 and size < A[i - 1]:
					MAX = max(MAX, 1 + FOO(i))
				elif dp[i] == None:
					dp[i] = FOO(i)
			dp[prev] = MAX
			return MAX
	MAX = 0
	for i in range(1, n + 1):
		MAX = max(MAX, FOO(i))
	print(MAX)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	dp = {}

	def recurse(i):
		if i in dp:
			return dp[i]
		if i < 1:
			return 0
		ans = 1
		j = 1
		while j * j <= i:
			if i % j == 0:
				if arr[i - 1] > arr[j - 1]:
					ans = max(ans, 1 + recurse(j))
				if j > 1:
					rem = i // j
					if arr[i - 1] > arr[rem - 1]:
						ans = max(ans, 1 + recurse(rem))
			j += 1
		dp[i] = ans
		return ans
	for i in range(1, n + 1):
		recurse(i)
	print(max(dp.values()))


import math, sys
from collections import defaultdict, Counter, deque
INF = float('inf')
MOD = int(1000000000.0) + 7

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def primeFactors(n):
	factors = defaultdict(int)
	i = 2
	while i ** 2 <= n:
		while n % i == 0:
			factors[i] += 1
			n //= i
		i += 1
	if n > 1:
		factors[n] += 1
	return factors

def vars():
	return map(int, input().split())

def array():
	return list(map(int, input().split()))

def main():
	n = int(input())
	arr = array()
	dp = [1 for i in range(n + 1)]
	for i in range(1, n + 1):
		add = 0
		for j in range(1, int(i ** 0.5) + 1, 1):
			if i % j == 0:
				if arr[i - 1] > arr[j - 1]:
					add = max(add, dp[j])
				k = i // j
				if arr[i - 1] > arr[k - 1]:
					add = max(add, dp[k])
		dp[i] += add
	print(max(dp))
t = 1
t = int(input())
for _ in range(t):
	main()


import random
import math
import sys
LI = lambda : list(map(int, input().split()))
MI = lambda : map(int, input().split())
yes = lambda : print('Yes')
no = lambda : print('No')
I = lambda : list(input())
J = lambda x: ''.join(x)
II = lambda : int(input())
SI = lambda : input()
t = II()
for q in range(t):
	n = II()
	s = LI()
	s = [0] + s
	dp = [1] * (n + 1)
	for i in range(1, n + 1):
		for j in range(2 * i, n + 1, i):
			if s[j] > s[i]:
				dp[j] = max(dp[j], dp[i] + 1)
	print(max(dp))


import sys
readline = sys.stdin.readline

def solve():
	N = int(readline())
	S = list(map(int, readline().split()))
	mem = [-1] * (len(S) + 1)
	ans = 0

	def rec(i):
		nonlocal ans
		if mem[i] != -1:
			return mem[i]
		ret = 1
		for j in range(i * 2, len(S) + 1, i):
			if S[j - 1] > S[i - 1]:
				ret = max(ret, 1 + rec(j))
		mem[i] = ret
		ans = max(ans, ret)
		return ret
	for i in range(1, len(S) + 1):
		rec(i)
	print(ans)
T = int(readline())
for i in range(T):
	solve()


for _ in range(int(input())):
	n = int(input())
	ar = [int(x) for x in input().split()]
	d = {}
	fr = [0] * (n + 1)
	for i in range(n):
		val = ar[i]
		temp = i + 1
		sm = temp
		while sm <= n:
			if ar[sm - 1] > ar[temp - 1]:
				fr[sm] = max(fr[sm], fr[temp] + 1)
			sm += temp
	mx = 0
	for i in fr:
		mx = max(mx, i)
	print(mx + 1)