#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int P = 998244353;

int norm(int x) { return x >= P ? (x - P) : x; }

void add(int &x, int y) { if ((x += y) >= P) x -= P; }

void sub(int &x, int y) { if ((x -= y) < 0) x += P; }

void exGcd(int a, int b, int &x, int &y) {
  if (!b) {
    x = 1;
    y = 0;
    return;
  }
  exGcd(b, a % b, y, x);
  y -= a / b * x;
}

int inv(int a) {
  int x, y;
  exGcd(a, P, x, y);
  return norm(x + P);
}

int mpow(int x, int k) {
  int ret = 1;
  while (k) {
    if (k & 1)
      ret = ret * (ll) x % P;
    x = x * (ll) x % P;
    k >>= 1;
  }
  return ret;
}

struct Mat {
  int g[3][3];

  Mat() { memset(g, 0, sizeof(g)); }

  Mat operator*(const Mat &rhs) const {
    Mat ret = Mat();
    for (int i = 0; i < 3; ++i)
      for (int j = 0; j < 3; ++j)
        for (int k = 0; k < 3; ++k)
          ret.g[i][k] = (ret.g[i][k] + g[i][j] * (ll) rhs.g[j][k]) % P;
    return ret;
  }
};

Mat power(Mat mat, int k) {
  Mat ret = Mat();
  for (int i = 0; i < 3; ++i) ret.g[i][i] = 1;
  while (k) {
    if (k & 1)
      ret = ret * mat;
    mat = mat * mat;
    k >>= 1;
  }
  return ret;
}

int len(int x) { return x * (1LL + x) / 2 % P; }

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, k;
  cin >> n >> k;
  int nv = inv(n * (n + 1LL) / 2 % P);
  int ans = 0;
  function<void(int, int, int, int, int)> dfs = [&](int l, int r, int cov, int oth, int exa) {
    // 0: no, noprt
    // 1: have
    // 2: no, haveprt

    // u: cover but dont pushto
    // v: go across
    // w: pushto
    // y: nothing happened
    // z: exact

    //cerr << l << ", " << r << ": covdontpush " << cov << " pushto " << oth << " across "
    //     << ((r - l) * (n - (r - l + 1LL)) + len(r - l + 1) - 1) << ' ';

    int u = cov * (ll) nv % P, v = ((r - l) * (n - (r - l + 1LL)) + len(r - l + 1) - 1) % P * nv % P, w =
            oth * (ll) nv % P, z = exa * (ll)nv % P, y = (P * 5LL + 1 - u - v - w - z) % P;
    //cerr << "exact " << exa << " rest " << (y * (ll)len(n) % P) << '\n';
    Mat trans = Mat();
    trans.g[0][0] = norm(norm(v + w) + y);
    trans.g[0][1] = z;
    trans.g[0][2] = u;
    trans.g[1][0] = v;
    trans.g[1][1] = norm(norm(w + norm(u + z)) + y);
    trans.g[2][0] = v;
    trans.g[2][1] = norm(w + z);
    trans.g[2][2] = norm(u + y);

    add(ans, power(trans, k).g[0][1]);
    //cerr << l << ", " << r << ": " << (power(trans, k).g[0][1] * (ll) mpow(len(n), k) % P) << "/" << mpow(len(n), k)
    //     << '\n';

    add(cov, exa);
    if (l < r) {
      int mid;
      cin >> mid;
      dfs(l, mid, cov, ((r - mid) * (ll) (n - r) + len(r - mid)) % P, l * (ll)(r - mid) % P);
      dfs(mid + 1, r, cov, ((mid - l + 1) * (l - 1LL) + len(mid - l + 1)) % P, (mid - l + 1LL) * (n - r + 1) % P);
    }
  };
  dfs(1, n, 0, 0, 1);
  //cerr << (ans * (ll)mpow(len(n), k) % P) << '\n';
  cout << ans << '\n';

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}