#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
namespace my{
#define eb emplace_back
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define RDVL(T,n,...) vec<T>__VA_ARGS__;resizes({n},__VA_ARGS__);lin(__VA_ARGS__)
#define VL(n,...) RDVL(ll,n,__VA_ARGS__)
#define jo(a,b) a##b
#define FO_IMPL(n,c) for(ll jo(_i,c)=n;jo(_i,c)-->0;)
#define FO(n) FO_IMPL(n,__COUNTER__)
#define FOR(i,...) for(auto[i,i##stop,i##step]=range(0,__VA_ARGS__);i<i##stop;i+=i##step)
#define fo(i,...) FO##__VA_OPT__(R)(i __VA_OPT__(,__VA_ARGS__))
#define of(i,...) for(auto[i,i##stop,i##step]=range(1,__VA_ARGS__);i>=i##stop;i+=i##step)
#define fe(a,e,...) for(auto&&__VA_OPT__([)e __VA_OPT__(,__VA_ARGS__]):a)
#define maybe(p,c) (p?c:remove_cvref_t<decltype(c)>{})
#define base_operator(op,type) auto operator op(const type&v)const{auto copy=*this;return copy op##=v;}
#define entry void solve();void solve2();}int main(){my::io();my::solve();}namespace my{
#define use_ml998244353 using ml=atcoder::modint998244353;
auto&operator>>(istream&i,atcoder::modint998244353&x){int t;i>>t;x=t;return i;}
auto&operator<<(ostream&o,const atcoder::modint998244353&x){return o<<(int)x.val();}
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
using ull=unsigned long long;
using i64=int64_t;
using ui64=uint64_t;
using ui128=__uint128_t;
using i8=int8_t;
ostream&operator<<(ostream&o,const i8&x){return o<<(int)x;}
constexpr auto range(ll s,ll b){ll a=0;if(s)swap(a,b);return array{a-s,b,1-s*2};}
constexpr auto range(ll s,ll a,ll b,ll c=1){return array{a-s,b,(1-s*2)*c};}
const string newline{char(10)};
const string space{char(32)};
constexpr auto abs(auto x){return x<0?-x:x;}
constexpr auto pow(auto x,auto n,auto e){assert(n>=0);decltype(x)r=e;for(;n;x*=x,n>>=1)if(n&1)r*=x;return r;}
constexpr auto pow(auto x,auto n){return pow(x,n,1);}
auto max(auto...a){return max(initializer_list<common_type_t<decltype(a)...>>{a...});}
template<class T,class U>common_type_t<T,U>gcd(T a,U b){return b?gcd(b,a%b):abs(a);}
auto gcd(auto...a){common_type_t<decltype(a)...>r=0;((r=gcd(r,a)),...);return r;}
ll rand(){static ll x=495;x^=x<<7;x^=x>>9;return x;}
ll rand(ll l,ll r=0){if(l>r)swap(l,r);return rand()%(r-l)+l;}

template<class A,class B>struct pair{
  A a;B b;
  pair()=default;
  pair(A a,B b):a(a),b(b){}
  pair(const std::pair<A,B>&p):a(p.first),b(p.second){}
  auto operator<=>(const pair&)const=default;
  pair operator+(const pair&p)const{return{a+p.a,b+p.b};}
  friend istream&operator>>(istream&i,pair&p){return i>>p.a>>p.b;}
  friend ostream&operator<<(ostream&o,const pair&p){return o<<p.a<<space<<p.b;}
};

template<class F=less<>>auto&sort(auto&a,F f={}){ranges::sort(a,f);return a;}

template<class...A>using pack_back_t=tuple_element_t<sizeof...(A)-1,tuple<A...>>;

template<class V>concept vectorial=is_base_of_v<vector<typename remove_cvref_t<V>::value_type>,remove_cvref_t<V>>;
template<class V>constexpr int rank(){if constexpr(vectorial<V>)return rank<typename V::value_type>()+1;else return 0;}
template<class T>struct core_t_helper{using core_t=T;};
template<vectorial V>struct core_t_helper<V>{using core_t=typename core_t_helper<typename V::value_type>::core_t;};
template<class T>using core_t=core_t_helper<T>::core_t;
template<class V>istream&operator>>(istream&i,vector<V>&v){fe(v,e)i>>e;return i;}
template<class T>ostream&operator<<(ostream&o,const vector<T>&v){ll n=v.size();fo(i,n)o<<v[i]<<maybe(i<n-1,space);return o;}
template<vectorial V>ostream&operator<<(ostream&o,const vector<V>&v){ll n=v.size();fo(i,n)o<<v[i]<<maybe(i<n-1,newline);return o;}

template<class V>struct vec;
template<int rank,class T>struct hvec_helper{using type=vec<typename hvec_helper<rank-1,T>::type>;};
template<class T>struct hvec_helper<0,T>{using type=T;};
template<int rank,class T>using hvec=typename hvec_helper<rank,T>::type;

template<class V>struct vec:vector<V>{
  static constexpr int R=rank<vec<V>>();
  using C=core_t<V>;
  using vector<V>::vector;
  vec(const vector<V>&v){vector<V>::operator=(v);}
  vec(const auto&...a)requires(sizeof...(a)>=3){resizes(a...);}
  void resizes(const auto&...a){*this=make(a...);}
  static auto make(ll n,const auto&...a){
    if constexpr(sizeof...(a)==1)return vec<C>(n,array{a...}[0]);
    else return vec<decltype(make(a...))>(n,make(a...));
  }

  vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;}
  vec&operator+=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]+=u[i];return v;}
  vec&operator-=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]-=u[i];return v;}
  vec&operator+=(const C&c){fe(*this,e)e+=c;return*this;}
  vec&operator*=(const C&c){fe(*this,e)e*=c;return*this;}
  base_operator(^,vec)
  base_operator(+,vec)
  base_operator(-,vec)
  base_operator(+,C);
  base_operator(*,C);

  vec&operator++(){fe(*this,e)++e;return*this;}
  vec&operator--(){fe(*this,e)--e;return*this;}

  ll size()const{return vector<V>::size();}

  auto&emplace_back(auto&&...a){vector<V>::emplace_back(std::forward<decltype(a)>(a)...);return*this;}

  auto scan(const auto&f)const{
    pair<C,bool>r{};
    fe(*this,e)if constexpr(!vectorial<V>)r.b?f(r.a,e),r:r={e,1};else if(auto s=e.scan(f);s.b)r.b?f(r.a,s.a),r:r=s;
    return r;
  }
  auto sum()const{return scan([](auto&a,const auto&b){a+=b;}).a;}
  auto max()const{return scan([](auto&a,auto b){if(a<b)a=b;}).a;}

  vec mobius()const{vec v=*this;if constexpr(vectorial<V>)fe(v,e)e=e.mobius();of(i,v.size()-1)v[i+1]-=v[i];return v;}

  template<class F=less<>>auto sort(F f={})const{vec v=*this;ranges::sort(v,f);return v;}

  auto transform(const auto&f)const{
    hvec<R,decltype(f(C()))>res(size());
    if constexpr(vectorial<V>)fo(i,size())res[i]=(*this)[i].transform(f);
    else std::transform(this->begin(),this->end(),res.begin(),f);
    return res;
  }

  auto rle()const{vec<pair<V,ll>>r;fe(*this,e)if(r.size()&&e==r.back().a)++r.back().b;else r.eb(e,1);return r;}
  auto rce()const{return sort().rle();}

  auto as()const{return transform([](const auto&e){return e.a;});}
};
template<class...A>requires(sizeof...(A)>=2)vec(const A&...a)->vec<hvec<sizeof...(A)-2,pack_back_t<A...>>>;
vec(ll)->vec<ll>;

template<class...A>void resizes(const array<ll,common_type_t<A...>::R+1>&s,A&...a){(apply([&](const auto&...b){a.resizes(b...); },s),...);}
auto pack_vec(const auto&...a){return vec<common_type_t<decltype(a)...>>{a...};}

void lin(auto&...a){(cin>>...>>a);}

void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<maybe(--n>0,space)),...);cout<<newline;}

template<int tag=-1>struct montgomery64{
  using modular=montgomery64;
  static inline ui64 N=998244353;
  static inline ui64 N_inv=996491785301655553ull;
  static inline ui64 R2=299560064;

  static int set_mod(ui64 N){
    if(modular::N==N)return 0;
    assert(N<(1ull<<63));
    assert(N&1);
    modular::N=N;
    R2=-ui128(N)%N;
    N_inv=N;
    fo(5)N_inv*=2-N*N_inv;
    assert(N*N_inv==1);
    return 0;
  }

  ui64 a;
  montgomery64(const i64&a=0):a(reduce((ui128)(a%(i64)N+N)*R2)){}

  static ui64 reduce(const ui128&T){ui128 r=(T+ui128(ui64(T)*-N_inv)*N)>>64;return r>=N?r-N:r;}

  auto&operator+=(const modular&b){if((a+=b.a)>=N)a-=N;return*this;}
  auto&operator-=(const modular&b){if(i64(a-=b.a)<0)a+=N;return*this;}
  auto&operator*=(const modular&b){a=reduce(ui128(a)*b.a);return*this;}
  auto&operator/=(const modular&b){*this*=b.inv();return*this;}

  friend auto operator+(const modular&a,const modular&b){return modular{a}+=b;}
  friend auto operator-(const modular&a,const modular&b){return modular{a}-=b;}
  friend auto operator*(const modular&a,const modular&b){return modular{a}*=b;}
  friend auto operator/(const modular&a,const modular&b){return modular{a}/=b;}
  friend bool operator==(const modular&a,const modular&b){return a.a==b.a;}
  auto operator-()const{return modular{}-modular{*this};}

  modular pow(ui128 n)const{return my::pow(*this,n);}

  modular inv()const{ui64 a=val(),b=N,u=1,v=0;assert(gcd(a,b)==1);while(b)swap(u-=a/b*v,v),swap(a-=a/b*b,b);return u;}
  ui64 val()const{return reduce(a);}

  friend istream&operator>>(istream&i,montgomery64<tag>&b){ll t;i>>t;b=t;return i;}
  friend ostream&operator<<(ostream&o,const montgomery64<tag>&b){return o<<b.val();}
};

template<class T>T one(T n){return n>0;}

void sort(auto&...a){auto v=pack_vec(a...).sort();ll i=0;((a=v[i++]),...);}

bool miller_rabin(ll n,vec<ll>as){
  ll d=n-1;
  while(~d&1)d>>=1;

  using modular=montgomery64<1>;
  modular::set_mod(n);

  modular one=1,minus_one=n-1;
  fe(as,a){
    if(a%n==0)continue;
    ll t=d;
    modular y=modular(a).pow(t);
    while(t!=n-1&&y!=one&&y!=minus_one)y*=y,t<<=1;
    if(y!=minus_one&&~t&1)return 0;
  }
  return 1;
}

bool is_prime(ll n){
  if(~n&1)return n==2;
  if(n<=1)return 0;
  if(n<4759123141LL)return miller_rabin(n,{2,7,61});
  return miller_rabin(n,{2,325,9375,28178,450775,9780504,1795265022});
}

ll pollard_rho(ll n){
  if(~n&1)return 2;
  if(is_prime(n))return n;

  using modular=montgomery64<2>;
  modular::set_mod(n);

  modular R,one=1;
  auto f=[&](const modular&x){return x*x+R;};
  while(1){
    modular x,y,ys,q=one;
    R=rand(2,n),y=rand(2,n);
    ll g=1;
    constexpr ll m=128;
    for(ll r=1;g==1;r<<=1){
      x=y;
      fo(r)y=f(y);
      for(ll k=0;g==1&&k<r;k+=m){
        ys=y;
        for(ll i=0;i<m&&i<r-k;++i)q*=x-(y=f(y));
        g=std::gcd(q.val(),n);
      }
    }
    if(g==n)do g=std::gcd((x-(ys=f(ys))).val(),n);while(g==1);
    if(g!=n)return g;
  }
}

auto factorize(ll n){
  assert(n>0);
  vec<ll>res;
  auto f=[&](auto&f,ll m){
    if(m==1)return;
    auto d=pollard_rho(m);
    if(d==m)res.eb(d);
    else f(f,d),f(f,m/d);
  };
  f(f,n);
  return res.rce();
}

auto radical(ll n){ll res=1;fe(factorize(n),p,q)res*=p;return res;}

auto divisors(const vec<pair<ll,ll>>&prime_exponent){
  vec<ll>r{1};
  for(auto[p,e]:prime_exponent){
    ll sz=size(r);
    for(ll t=p;e;--e,t*=p)fo(i,sz)r.eb(r[i]*t);
  }
  return sort(r);
}
auto divisors(ll n){return divisors(factorize(n));}

ll mobius_prime_pow(ll,i8 k,ll){return-(k==1);}

ll mobius(ll n){ll r=1;fe(factorize(n),p,q)r*=mobius_prime_pow(p,q,pow(p,q));return r;}

template<class T>struct linear_sieve{
  T n;
  vec<int>lpf;
  vec<i8>lpf_ord;
  vec<int>lpf_pow;
  vec<int>lpf_pow_except;
  vec<int>primes;
  linear_sieve(T n):n(n),lpf(n+1,-1),lpf_ord(n+1),lpf_pow(n+1),lpf_pow_except(n+1){
    lpf[1]=lpf_ord[1]=lpf_pow[1]=lpf_pow_except[1]=1;

    fo(i,2,n+1){
      if(lpf[i]==-1)primes.eb(lpf[i]=i);

      fe(primes,p){
        if(p*i>n||p>lpf[i])break;
        lpf[p*i]=p;
      }

      int j=i/lpf[i];
      lpf_ord[i]=lpf_ord[j]*(lpf[i]==lpf[j])+1;
      lpf_pow[i]=((lpf_pow[j]-1)*(lpf[i]==lpf[j])+1)*lpf[i];
      lpf_pow_except[i]=i/lpf_pow[i];
    }
  }

  auto multiplicative_function_enumerate(const auto&f)const{
    vec<T>r(n+1);
    r[1]=1;
    fo(i,2,n+1)r[i]=f(lpf[i],lpf_ord[i],lpf_pow[i])*r[lpf_pow_except[i]];
    return r;
  }

  auto mobius_enumerate()const{return multiplicative_function_enumerate(mobius_prime_pow);}

  auto factorize(T x)const{
    assert(x<=n);
    vec<pair<T,T>>res;
    for(;x>1;x=lpf_pow_except[x])res.eb(lpf[x],lpf_ord[x]);
    return res;
  }

  auto radical(T x)const{
    assert(x<=n);
    T res=1;
    for(;x>1;x=lpf_pow_except[x])res*=lpf[x];
    return res;
  }

  auto divisors(ll x)const{
    assert(x<=n);
    vec<T>res{1};
    fe(factorize(x),p,e){
      ll m=res.size();
      for(T t=p;e;--e,t*=p)fo(i,m)res.eb(res[i]*t);
    }
    return sort(res);
  }
};

entry
void solve(){
  LL(N);
  VL(N,a);
  ll M=a.max()+1;

  linear_sieve<ll>ls(M);
  auto mobius=ls.mobius_enumerate();
  use_ml998244353
  ml su=0; // dp.sum()
  vec<ml>dp(M);
  vec<ml>g(M);
  fe(a,e){
    e=ls.radical(e);

    ml f1=0;
    fe(ls.divisors(e),x)f1+=mobius[x]*g[x];

    ml diff=1+su-f1;
    dp[e]+=diff;
    su+=diff;
    fe(ls.divisors(e),x)g[x]+=diff;
  }
  pp(su);
}}