#include using namespace std; #define INF_LL (int64)1e18 #define INF (int32)1e9 #define REP(i, n) for(int64 i = 0;i < (n);i++) #define FOR(i, a, b) for(int64 i = (a);i < (b);i++) #define all(x) x.begin(),x.end() #define fs first #define sc second using int32 = int_fast32_t; using uint32 = uint_fast32_t; using int64 = int_fast64_t; using uint64 = uint_fast64_t; using PII = pair; using PLL = pair; const double eps = 1e-10; templateinline void chmin(A &a, B b){if(a > b) a = b;} templateinline void chmax(A &a, B b){if(a < b) a = b;} template vector make_v(size_t a){return vector(a);} template auto make_v(size_t a,Ts... ts){ return vector(ts...))>(a,make_v(ts...)); } template typename enable_if::value!=0>::type fill_v(U &u,const V... v){u=U(v...);} template typename enable_if::value==0>::type fill_v(U &u,const V... v){ for(auto &e:u) fill_v(e,v...); } class UnionFind{ private: ::std::vector par; size_t n; public: UnionFind(){} UnionFind(size_t n):n(n){ par.resize(n, -1); } uint_fast32_t find(uint_fast32_t x){ return par[x] < 0 ? x : par[x] = find(par[x]); } size_t size(uint_fast32_t x){ return -par[find(x)]; } bool unite(uint_fast32_t x, uint_fast32_t y){ x = find(x); y = find(y); if(x == y) return false; if(size(x) < size(y)) std::swap(x, y); par[x] += par[y]; par[y] = x; return true; } bool same(uint_fast32_t x, uint_fast32_t y){ return find(x) == find(y); } }; template<::std::uint_fast64_t mod> class ModInt{ private: using value_type = ::std::uint_fast64_t; value_type n; public: ModInt() : n(0) {} ModInt(value_type n_) : n(n_ % mod) {} ModInt(const ModInt& m) : n(m.n) {} template explicit operator T() const { return static_cast(n); } value_type get() const { return n; } friend ::std::ostream& operator<<(::std::ostream &os, const ModInt &a) { return os << a.n; } friend ::std::istream& operator>>(::std::istream &is, ModInt &a) { value_type x; is >> x; a = ModInt(x); return is; } bool operator==(const ModInt& m) const { return n == m.n; } bool operator!=(const ModInt& m) const { return n != m.n; } ModInt& operator*=(const ModInt& m){ n = n * m.n % mod; return *this; } ModInt pow(value_type b) const{ ModInt ans = 1, m = ModInt(*this); while(b){ if(b & 1) ans *= m; m *= m; b >>= 1; } return ans; } ModInt inv() const { return (*this).pow(mod-2); } ModInt& operator+=(const ModInt& m){ n += m.n; n = (n < mod ? n : n - mod); return *this; } ModInt& operator-=(const ModInt& m){ n += mod - m.n; n = (n < mod ? n : n - mod); return *this; } ModInt& operator/=(const ModInt& m){ *this *= m.inv(); return *this; } ModInt operator+(const ModInt& m) const { return ModInt(*this) += m; } ModInt operator-(const ModInt& m) const { return ModInt(*this) -= m; } ModInt operator*(const ModInt& m) const { return ModInt(*this) *= m; } ModInt operator/(const ModInt& m) const { return ModInt(*this) /= m; } ModInt& operator++(){ n += 1; return *this; } ModInt& operator--(){ n -= 1; return *this; } ModInt operator++(int){ ModInt old(n); n += 1; return old; } ModInt operator--(int){ ModInt old(n); n -= 1; return old; } ModInt operator-() const { return ModInt(mod-n); } }; template<::std::size_t size, ::std::uint_fast64_t mod=1000000007> class Factorial{ private: using value_type = ModInt; ::std::vector fact, inv; public: Factorial() : fact(size+1, 1), inv(size+1, 1){ for(::std::size_t i = 1; i <= size; ++i){ fact[i] = fact[i-1] * value_type(i); inv[i] = fact[i].inv(); } } value_type comb(::std::int64_t a, ::std::int64_t b){ assert(a >= b); assert(b >= 0); return fact[a]*inv[b]*inv[a-b]; } value_type& operator[](::std::size_t k){ return fact[k]; } }; constexpr int64 mod = 1e9+7; using Mint = ModInt; Factorial<2020> f; int main(void) { cin.tie(0); ios::sync_with_stdio(false); int64 N; cin >> N; vector A(N); vector mp(312345, 0); REP(i, N) cin >> A[i]; int64 res = 0; REP(i, N) { int64 x = 0; for(int64 j = 1; j*j <= A[i]; j++) { if (A[i] % j != 0) continue; chmax(x, mp[j]); if (j != 1) chmax(x, mp[A[i]/j]); } chmax(mp[A[i]], x+1); chmax(res, x+1); } cout << res << endl; }