Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a_1, a_2, ..., a_{n} are good.

Now she is interested in good sequences. A sequence x_1, x_2, ..., x_{k} is called good if it satisfies the following three conditions:  The sequence is strictly increasing, i.e. x_{i} < x_{i} + 1 for each i (1 ≤ i ≤ k - 1).  No two adjacent elements are coprime, i.e. gcd(x_{i}, x_{i} + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).  All elements of the sequence are good integers. 

Find the length of the longest good sequence.


-----Input-----

The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of good integers. The second line contains a single-space separated list of good integers a_1, a_2, ..., a_{n} in strictly increasing order (1 ≤ a_{i} ≤ 10^5; a_{i} < a_{i} + 1).


-----Output-----

Print a single integer — the length of the longest good sequence.


-----Examples-----
Input
5
2 3 4 6 9

Output
4

Input
9
1 2 3 5 6 7 8 9 10

Output
4



-----Note-----

In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.

Difficulty: MEDIUM

Solutions:
def main():
	input()
	d = {}
	for a in map(int, input().split()):
		(z, l) = (0, [])
		for p in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313):
			if not a % p:
				l.append(p)
				x = d.get(p, 0)
				if z < x:
					z = x
				a //= p
				while not a % p:
					a //= p
				if a == 1:
					break
		else:
			l.append(a)
			x = d.get(a, 0)
			if z < x:
				z = x
		d.update(dict.fromkeys(l, z + 1))
	print(max(d.values()))
main()


import math
N = 100100

def solve(ar):
	n = len(ar)
	dp = [0 for i in range(N + 20)]
	for a in ar:
		x = math.sqrt(a)
		dp[a] = 1
		for j in range(2, a):
			if j * j <= a:
				if a % j == 0:
					dp[a] = max(dp[a], max(dp[a // j] + 1, dp[j] + 1))
			else:
				break
		for j in range(2, a):
			if j * j <= a:
				if a % j == 0:
					dp[j] = dp[a // j] = dp[a]
			else:
				break
	m = 1
	for x in range(1, 100100):
		m = max(m, dp[x])
	return m
n = int(input())
ar = list(map(int, input().split()))
x = solve(ar)
print(x)


from sys import stdin
mem = [0 for i in range(int(100000.0 + 1))]

def solve(tc):
	n = int(stdin.readline().strip())
	seq = list(map(int, stdin.readline().split()))
	if n == 1:
		print(1)
		return
	ans = 0
	for i in range(n):
		num = seq[i]
		divisor = set()
		p = 2
		while p * p <= num:
			while num % p == 0:
				divisor.add(p)
				num //= p
			p += 1
		if num > 1:
			divisor.add(num)
		for dn in divisor:
			mem[seq[i]] = max(mem[seq[i]], mem[dn] + 1)
		for dn in divisor:
			mem[dn] = mem[seq[i]]
		ans = max(ans, mem[seq[i]])
	print(ans)
tcs = 1
for tc in range(tcs):
	solve(tc)


from collections import defaultdict
import math

def primeFactors(n):
	prime = set()
	while n % 2 == 0:
		prime.add(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			prime.add(i)
			n = n // i
	if n > 2:
		prime.add(n)
	return list(prime)
n = int(input())
a = list(map(int, input().split()))
l = defaultdict(int)
for i in range(n):
	pf = primeFactors(a[i])
	mx = 0
	for j in pf:
		mx = max(mx, l[j])
	for j in pf:
		l[j] = mx + 1
mx = 1
for (k, v) in l.items():
	mx = max(mx, v)
print(mx)


p = 10 ** 5 + 9
t = [[] for i in range(p)]
dp = [0] * p
for i in range(2, p):
	if not t[i]:
		t[i].append(i)
	for j in range(2 * i, p, i):
		t[j].append(i)
n = int(input())
l = [int(i) for i in input().split()]
if n == 1:
	print(1)
	return
for i in l:
	maxi = 0
	for j in t[i]:
		maxi = max(maxi, dp[j])
	dp[i] = maxi + 1
	for j in t[i]:
		dp[j] = maxi + 1
print(max(dp))


import math
primes = []

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	for p in range(n + 1):
		if prime[p]:
			primes.append(p)
SieveOfEratosthenes(6000)
dp = [0 for i in range(max(primes) + 1)]
n = int(input())
arr = list(map(int, input().strip().split()))
try:
	for i in arr:
		p = []
		for j in primes:
			if j > i:
				break
			if i % j == 0:
				p.append(j)
		maxi = 0
		for j in p:
			maxi = max(dp[j] + 1, maxi)
		for j in p:
			dp[j] = maxi
	print(max(max(dp), 1))
except Exception as e:
	print(e)


import sys
input = sys.stdin.buffer.readline
import math

def solution():
	n = int(input())
	l = list(map(int, input().split()))
	dp = [0] * 100005
	cnt = [0] * 100005
	ans = 0
	for i in range(n):
		x = l[i]
		for j in range(1, int(x ** 0.5) + 1):
			if x % j == 0:
				cnt[i + 1] = max(cnt[i + 1], cnt[dp[x // j]] + 1)
				if j > 1:
					cnt[i + 1] = max(cnt[i + 1], cnt[dp[j]] + 1)
				ans = max(ans, cnt[i + 1])
				dp[j] = i + 1
				dp[x // j] = i + 1
	print(ans)
solution()


import math
a = int(input())
z = list(map(int, input().split()))
dp = [0 for i in range(max(z) + 1)]
dp[0] = 1

def fact(x):
	ans = []
	for i in range(2, int(math.sqrt(x)) + 1):
		if x % i == 0:
			if x // i != i:
				ans.append(i)
				ans.append(x // i)
			else:
				ans.append(i)
	ans.append(x)
	return ans
for i in range(len(z)):
	t = fact(z[i])
	maxa = 0
	for i in range(len(t)):
		maxa = max(maxa, dp[t[i]])
	for i in range(len(t)):
		dp[t[i]] = maxa + 1
print(max(dp))


R = lambda : map(int, input().split())
(prime, cnt) = ([1] * 10001, [0] * 10001)
pms = []
for i in range(2, 10001):
	if prime[i]:
		for j in range(i + i, 10001, i):
			prime[j] = 0
		pms.append(i)
n = int(input())
for x in R():
	mx = 0
	coms = []
	for p in pms:
		if x < p:
			break
		if x % p == 0:
			mx = max(mx, cnt[p] + 1)
			coms.append(p)
	for x in coms:
		cnt[x] = mx
print(max(cnt + [1]))


n = 100001
m = int(input())
div = [[] for _ in range(n)]
div[1] = [1]
for i in range(2, n):
	if not div[i]:
		div[i] = [i]
		for j in range(2 * i, n, i):
			div[j].append(i)
a = list(map(int, input().rstrip().split()))
dp = [0] * (n + 1)
for i in a:
	x = max((dp[j] for j in div[i])) + 1
	for j in div[i]:
		dp[j] = x
print(max(dp))


n = int(input())
x = list(map(int, input().split()))
v = [[] for i in range(100001)]
(max, ans) = ([0] * 100001, 0)
for i2 in range(1, x[n - 1] + 1):
	for i in range(i2, x[n - 1] + 1, i2):
		v[i].append(i2)
for i in range(n):
	temp = 0
	for i2 in range(1, len(v[x[i]])):
		if temp < max[v[x[i]][i2]]:
			temp = max[v[x[i]][i2]]
	temp += 1
	for i2 in range(1, len(v[x[i]])):
		if temp > max[v[x[i]][i2]]:
			max[v[x[i]][i2]] = temp
	if ans < temp:
		ans = temp
print(ans)


import bisect
import sys
import math as mt
import collections
import heapq
t = 1
p = 10 ** 9 + 7

def ncr_util():
	inv[0] = inv[1] = 1
	fact[0] = fact[1] = 1
	for i in range(2, 300001):
		inv[i] = inv[i % p] * (p - p // i) % p
	for i in range(1, 300001):
		inv[i] = inv[i - 1] * inv[i] % p
		fact[i] = fact[i - 1] * i % p

def solve():
	dp = [0] * (n + 1)
	if n == 1:
		return 1
	d = {}
	for i in range(n):
		j = 1
		(x, ind) = (0, -1)
		while j * j <= l[i]:
			if l[i] % j == 0:
				if l[i] // j == j and j != 1:
					if d.get(j, -1) != -1:
						x = max(x, d[j])
				else:
					if d.get(j, -1) != -1 and j != 1:
						x = max(x, d[j])
					if d.get(l[i] // j, -1) != -1 and l[i] // j != 1:
						x = max(x, d[l[i] // j])
			j += 1
		j = 1
		while j * j <= l[i]:
			if l[i] % j == 0:
				if l[i] // j == j and j != 1:
					d[j] = max(d.get(j, 0), x + 1)
				else:
					if j != 1:
						d[j] = max(d.get(j, 0), x + 1)
					if l[i] // j != 1:
						d[l[i] // j] = max(d.get(l[i] // j, 0), x + 1)
			j += 1
	maxi = 0
	for i in d:
		maxi = max(maxi, d[i])
	return maxi
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	print(solve())


n = int(input())
a = list(map(int, input().split(' ')))
if a == [1] * n:
	print(1)
else:
	primes = [True for i in range(401)]
	primes[0] = False
	primes[1] = False
	for k in range(1, 401):
		if primes[k] == True:
			for pro in range(k * k, 401, k):
				primes[pro] = False
		mine = []
	for k in range(401):
		if primes[k]:
			mine.append(k)
	d = [0 for i in range(100001)]
	dp = [0 for i in range(n)]
	for k in range(n):
		al = a[k]
		for prime in mine:
			if al % prime == 0:
				dp[k] = max(d[prime] + 1, dp[k])
			while al % prime == 0:
				al //= prime
		for prime in mine:
			if a[k] % prime == 0:
				d[prime] = max(d[prime], dp[k])
		if al != 1:
			dp[k] = max(d[al] + 1, dp[k])
			d[al] = dp[k]
	print(max(dp))


from math import gcd
from math import ceil, sqrt
from collections import defaultdict

def largestPrime(N):
	largerPrime = list(range(N + 1))
	for i in range(2, N + 1):
		if largerPrime[i] == i:
			for j in range(i * 2, N + 1, i):
				largerPrime[j] = i
	return largerPrime
PrimeFactors = defaultdict(list)

def primeFactors(N):
	Large = largestPrime(N)
	for i in range(2, N + 1):
		temp = i
		while i != 1:
			fact = Large[int(i)]
			PrimeFactors[temp].append(Large[int(i)])
			while i % fact == 0:
				i /= fact
N = int(input())
List = [int(x) for x in input().split()]
primeFactors(max(List) + 1)
d = defaultdict(int)
for i in PrimeFactors[List[0]]:
	d[i] = 1
dp = [1] * (N + 1)
for i in range(1, N):
	for j in PrimeFactors[List[i]]:
		if d[j] != 0:
			dp[i] = max(dp[i], dp[d[j] - 1] + 1)
		d[j] = i + 1
print(max(dp))


import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import string
import sys
import time
from typing import Counter, List
sys.setrecursionlimit(99999)
input()
mx = 10 ** 5 + 5
f = [0] * mx
f[1] = 1
for i in range(2, mx):
	if f[i] == 0:
		f[i] = i
		for j in range(i * i, mx, i):
			if f[j] == 0:
				f[j] = i
mp = collections.defaultdict(int)
for c in map(int, input().split()):
	p = []
	while f[c] != c:
		k = f[c]
		p.append(k)
		while c % k == 0:
			c //= k
	if c > 1:
		p.append(c)
	if p:
		mx = max((mp[x] for x in p))
		for c in p:
			mp[c] = mx + 1
if mp:
	print(max(mp.values()))
else:
	print(1)


n = int(input())
a = [int(i) for i in input().split()]
m = max(a)
sieve = [i for i in range(m + 1)]
for i in range(2, m + 1):
	if sieve[i] == i:
		for j in range(i + i, m + 1, i):
			sieve[j] = i

def prime_factors(x):
	fs = set()
	while x > 1:
		f = sieve[x]
		x //= f
		fs.add(f)
	return fs
prev = {}
dp = [1 for _ in range(n)]
for i in range(n):
	fs = prime_factors(a[i])
	for f in fs:
		j = prev.get(f)
		if j is not None:
			dp[i] = max(dp[i], dp[j] + 1)
	for f in fs:
		prev[f] = i
print(max(dp))


n = 100001
(p, t) = ([0] * n, [[] for i in range(n)])
t[1] = [1]
for i in range(2, n):
	t[i].append(i)
	for j in range(2 * i, n, i):
		t[j].append(i)
n = input()
for i in map(int, input().split(' ')):
	x = max((p[j] for j in t[i])) + 1
	for j in t[i]:
		p[j] = x
print(max(p))


n = 10 ** 5 + 1
p = [0] * n
t = [[] for _ in range(n)]
t[1] = [1]
for i in range(2, n):
	if not t[i]:
		t[i] = [i]
		for j in range(2 * i, n, i):
			t[j].append(i)
m = input()
arr = list(map(int, input().split()))
x = 0
for i in arr:
	x = 0
	for j in t[i]:
		x = max(p[j], x)
	x += 1
	for j in t[i]:
		p[j] = x
print(max(p))


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 collections import Counter
import heapq
n = int(input())
arr = list(map(int, input().split()))
dp = [0 for i in range(arr[-1] + 1)]
for i in arr:
	divisors = set()
	for d in range(2, int(i ** 0.5) + 1):
		if i % d == 0:
			divisors.add(d)
			divisors.add(i // d)
	divisors.add(i)
	if divisors:
		dp[i] = max((dp[k] for k in divisors)) + 1
		for j in divisors:
			dp[j] = dp[i]
if n == 1:
	print(1)
else:
	print(max(dp))


from math import floor, sqrt

def div(x):
	primos = [1 for i in range(x + 1)]
	p = 2
	while p < x + 1:
		if primos[p] == 1:
			for i in range(p * p, x + 1, p):
				if primos[i] == 1:
					primos[i] = p
			primos[p] = p
		p += 1
	return primos

def fat(mindiv, x):
	fat = []
	while x != 1:
		fat.append(mindiv[x])
		x //= mindiv[x]
	return set(fat)

def main():
	n = int(input())
	if n == 1:
		print(1)
		return
	arr = input().split()
	arr = [int(x) for x in arr]
	mindiv = div(arr[-1])
	seq = [0 for i in range(arr[-1] + 1)]
	for num in arr:
		fatores = fat(mindiv, num)
		tam = 0
		for f in fatores:
			tam = max(tam, seq[f])
		for f in fatores:
			seq[f] = tam + 1
	print(max(seq))
	return
main()


from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1000000000.0) + 7
inf = float('inf')
(n,) = gil()
a = gil()

def getPrimes(x):
	p = []
	if x & 1 == 0:
		p.append(2)
	while x & 1 == 0:
		x //= 2
	for i in range(3, ceil(sqrt(x)) + 1):
		if x % i == 0:
			p.append(i)
		while x % i == 0:
			x //= i
	if x > 1:
		p.append(x)
	return p
primes = {}
ans = 1
for v in a:
	maxP = 0
	local_primes = getPrimes(v)
	for p in local_primes:
		maxP = max(maxP, primes.get(p, 0))
	for p in local_primes:
		primes[p] = maxP + 1
	ans = max(maxP + 1, ans)
print(ans)


import sys, os
from io import BytesIO, IOBase
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
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')
(stdin, stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def ceil(a, b):
	return (a + b - 1) // b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

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

def divs(n):
	ansl = []
	if n % 2 == 0:
		ansl.append(2)
		while n % 2 == 0:
			n //= 2
	j = 3
	while j * j <= n:
		if n % j == 0:
			ansl.append(j)
			while n % j == 0:
				n //= j
		j += 2
	if n > 1:
		ansl.append(n)
	return ansl
n = iinp()
arr = lmp()
dp = l1d(n)
f = dd(int)
for i in range(n):
	divisors = divs(arr[i])
	for x in divisors:
		dp[i] = max(dp[i], 1 + f[x])
	for x in divisors:
		f[x] = dp[i]
print(max(1, max(dp)))


import math
n = int(input())
l = list(map(int, input().split()))[:n]
dp = [0 for j in range(max(l) + 1)]
for x in l:
	divi = set()
	for k in range(2, int(math.sqrt(x)) + 1):
		if not x % k:
			divi.add(x // k)
			divi.add(k)
	divi.add(x)
	if divi:
		dp[x] = max([dp[k] for k in divi]) + 1
		for d in divi:
			dp[d] = dp[x]
if len(l) == 1:
	print(1)
else:
	print(max(dp))


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
			self.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 collections import defaultdict as dd, deque as dq
import math, string

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 10 ** 9 + 7

def prime_factors(n):
	factors = []
	num = 0
	while n % 2 == 0:
		num += 1
		n //= 2
	if num:
		factors.append(2)
	i = 3
	while n > 1 and i * i <= n:
		num = 0
		while n % i == 0:
			num += 1
			n //= i
		if num:
			factors.append(i)
		i += 2
	if n > 2:
		factors.append(n)
	return factors

def solve():
	N = getInt()
	A = [0] + getInts()
	prime_last_index = dd(int)
	dp = [1] * (N + 1)
	for i in range(1, N + 1):
		facs = prime_factors(A[i])
		for fac in facs:
			last = prime_last_index[fac]
			if last:
				dp[i] = max(dp[last] + 1, dp[i])
			prime_last_index[fac] = i
	return max(dp)
print(solve())