Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks *n* integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> are good.

Now she is interested in good sequences. A sequence *x*<sub class="lower-index">1</sub>, *x*<sub class="lower-index">2</sub>, ..., *x*<sub class="lower-index">*k*</sub> is called good if it satisfies the following three conditions:
 -  The sequence is strictly increasing, i.e. *x*<sub class="lower-index">*i*</sub> &lt; *x*<sub class="lower-index">*i* + 1</sub> for each *i* (1 ≤ *i* ≤ *k* - 1). -  No two adjacent elements are coprime, i.e. *gcd*(*x*<sub class="lower-index">*i*</sub>, *x*<sub class="lower-index">*i* + 1</sub>) &gt; 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.
The input consists of two lines. The first line contains a single integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — the number of good integers. The second line contains a single-space separated list of good integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> in strictly increasing order (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">5</sup>; *a*<sub class="lower-index">*i*</sub> &lt; *a*<sub class="lower-index">*i* + 1</sub>).

from math import sqrt
from collections import defaultdict
from bisect import bisect_right
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

from sys import stdin
def ret(s):
    n = len(s)
    j = 1
    i = 0
    start = -1
    flag = 0
    while j<n:

        if s[i] == s[j]:
# /,/            print(j)

            i+=1
            if flag == 0:
                flag = 1
                start = j
            j+=1

        else:
            start = -1
            i = 0
            if flag == 0:
              j+=1
            flag = 0



    if start == -1 or n%len(s[:start])!=0:
        return s
    else:
        return s[:start]

def cal(n):
    seti = set()
    for i in range(2,int(sqrt(n))+1):
        if n%i == 0:
            seti.add(n//i)
            seti.add(i)


    return seti

from collections import defaultdict
def solve():

    n = int(input())

    l = list(map(int,input().split()))
    hash = defaultdict(lambda : -1)
    dp = [0]*(n+1)
    for i in range(n):
        z = cal(l[i])
        dp[i] = 1
        for k in z:
            if hash[l[i]-k]>=0:
                z1 = hash[l[i]-k]
                dp[i] = max(dp[i],dp[z1]+1)




        hash[l[i]] = i
    # print(dp)
    print(max(dp))







# t = int(stdin.readline())
# for _ in range(t):
solve()



