// g++-13 1.cpp -std=c++17 -O2 -I .
#include <bits/stdc++.h>
using namespace std;

#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")

#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds;


#include <atcoder/modint>
#include <atcoder/maxflow>
#include <atcoder/math>
#include <atcoder/mincostflow>
using namespace atcoder;


using ll = long long;
using ld = long double;

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vst = vector<string>;
using vvst = vector<vst>;
 
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define pq_big(T) priority_queue<T,vector<T>,less<T>>
#define pq_small(T) priority_queue<T,vector<T>,greater<T>>
#define all(a) a.begin(),a.end()
#define rep(i,start,end) for(ll i=start;i<(ll)(end);i++)
#define per(i,start,end) for(ll i=start;i>=(ll)(end);i--)
#define uniq(a) sort(all(a));a.erase(unique(all(a)),a.end())

random_device seed;
mt19937_64 randint(seed());

ll grr(ll mi, ll ma) { // [mi, ma)
    return mi + randint() % (ma - mi);
}

// https://judge.yosupo.jp/submission/82871
// https://judge.yosupo.jp/submission/233535

#include <vector>

template< typename S, S (*op)(S, S), S (*e)() >
struct segmenttree{
  private:
  int _n;
  std::vector<S> node;

  public:
  segmenttree() = default;
    
  segmenttree(int n){
    _n=1;
    while(_n<n)_n*=2;
    node.resize(2*_n,e());
  }
  segmenttree(std::vector<S> &v){
    int n=v.size();
    _n=1;
    while(_n<n)_n*=2;
    node.resize(2*_n,e());
    for(int i=0;i<n;i++){
      node[i+_n]=v[i];
    }
    for(int i=_n-1;i>=0;i--){
      node[i]=op(node[2*i],node[2*i+1]);
    }
  }

  // [i] <- val
  void set(int i,S val){
    i+=_n;
    node[i]=val;
    while(i>1){
      i>>=1;
      node[i]=op(node[2*i],node[2*i+1]);
    }
  }

  // [i] <- op([i],val)
  void update(int i,S val){
    i+=_n;
    node[i]=op(node[i],val);
    while(i>1){
      i>>=1;
      node[i]=op(node[2*i],node[2*i+1]);
    }
  }

  S get(int i){
    i+=_n;
    return node[i];
  }

  S prod(int l,int r){
    S pdl=e(),pdr=e();
    l+=_n;r+=_n;

    while(l<r){
      if(l&1)pdl=op(pdl,node[l++]);
      if(r&1)pdr=op(node[--r],pdr);
      l>>=1;r>>=1;
    }

    return op(pdl,pdr);
  };
};


using mint = modint998244353;

mint op(mint a,mint b){
  return a+b;
}
mint e(){
  return 0;
}

int sq = 100;

mint f(int m,int x,int y){
  // ax > by かつ ax <= m なる (a, b) の個数
  // sum_a(= 0 to m / x - 1) floor((a * x + x - 1) / y)

  // 2a > 3b かつ 2a <= 7
  // 2-1/3 + 4-1/3 + 6-1/3
  mint res=floor_sum(m/x,y,x,x-1);

  // mint nv=0;
  // rep(i,1,m+1){
  //   rep(j,1,m+1){
  //     if(i*x>j*y&&i*x<=m){
  //       nv++;
  //     }
  //   }
  // }
  // if(nv!=res){
  //   cout<<m<<" "<<x<<" "<<y<<" "<<res.val()<<" "<<nv.val()<<endl;
  // }

  if(res.val()==0)return res;
  // cout<<m/x<<" "<<m/y<<endl;
  res/=(m/x);
  res/=(m/y);
  return res;
}

int main(){
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  auto st=clock();

  int n,m;cin>>n>>m;
  vi d(n);
  rep(i,0,n)cin>>d[i];

  segmenttree<mint,op,e> seg(m+1);
  vi cnt(sq+1,0);
  vector<mint> aft(sq+1,0);
  mint ans=0;

  vector<vector<mint>> f_large_small(sq+1,vector<mint>(m+1)),f_small_large(sq+1,vector<mint>(m+1));
  // f_large_small[i][j] := f(j,i)
  // f_small_large[i][j] := f(i,j)

  rep(i,1,sq+1){
    rep(j,1,m+1){
      f_large_small[i][j]=f(m,j,i);
      f_small_large[i][j]=f(m,i,j);
    }
  }

  auto ini=clock();
  cerr<<(ld)(ini-st)/(CLOCKS_PER_SEC)<<endl;

  rep(i,0,n){
    // cout<<ans.val()<<endl;
    if(d[i]>sq){
      // large large
      mint ad=1;
      ad/=(m/d[i]);
      rep(j,1,m+1){
        if(j*d[i]>m)break;
        ans+=seg.prod(j*d[i],m+1)*ad;
      }
      // cout<<" "<<ans.val()<<endl;
      // small large
      rep(j,1,sq+1){
        ans+=cnt[j]*f_small_large[j][d[i]];
        aft[j]+=f_large_small[j][d[i]];
      }
      // cout<<ad.val()<<endl;
      rep(j,1,m+1){
        if(j*d[i]>m)break;
        seg.update(j*d[i],ad);
      }
    }
    else{
      // large small
      ans+=aft[d[i]];

      // small small
      rep(j,1,sq+1){
        // if(cnt[j]>0)cout<<j<<"  : "<<cnt[j]<<"*"<<f_small_large[j][d[i]].val()<<endl;
        ans+=cnt[j]*f_small_large[j][d[i]];
      }

      cnt[d[i]]++;
    }
  }

  rep(i,0,n){
    ans*=(m/d[i]);
  }

  cout<<ans.val()<<endl;
}

/*
D large D large
D small D large
D small D small 前計算？
D large D small
*/