#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,K,N;
char s[600005];

int rk[600005],sa[600005],buc[600005],id[600005],pid[600005],ord[1200005],ST[20][600005];
inline int cmp(int x,int y,int len){
    return ord[x] != ord[y] || ord[x + len] != ord[y + len];
}

inline int qry(int l,int r){
    int x = __lg(r - l + 1);
    return min(ST[x][l],ST[x][r - (1 << x) + 1]);
}

inline int lcp(int x,int y){
    if(x == y) return N - x + 1;
    x = rk[x];y = rk[y];
    if(x > y) swap(x,y);
    return qry(x + 1,y);
}

void output(){
    rep(i,1,N){
        rep(j,sa[i],N) printf("%c",s[j]);
        printf("\n");
    }
}

void init(){
//    rep(i,1,N) printf("%c",s[i]);
//    printf("\n");
    int m = 26;
    rep(i,1,N) buc[s[i] - 'a']++;
    rep(i,1,m) buc[i] += buc[i - 1];
    rep(i,1,N) sa[buc[s[i] - 'a']--] = i;
    m = 0;
    rep(i,1,N){
        if(i == 1 || s[sa[i]] != s[sa[i] - 1]) m++;
        rk[sa[i]] = m;
    }

    for(int len = 1;len <= N;len *= 2){
        int cnt = 0;
        rep(i,N - len + 1,N) id[++cnt] = i;
        rep(i,1,N) if(sa[i] > len) id[++cnt] = sa[i] - len;
        fill(buc,buc + m + 1,0);
        rep(i,1,N) buc[pid[i] = rk[id[i]]]++;
        rep(i,1,m) buc[i] += buc[i - 1];
        per(i,N,1) sa[buc[pid[i]]--] = id[i];
        copy(rk + 1,rk + N + 1,ord + 1);
        m = 0;
        rep(i,1,N){
            if(i == 1 || cmp(sa[i],sa[i - 1],len)) m++;
            rk[sa[i]] = m;
        } 
//        printf("len=%d\n",len);
//        output();
        if(m == N) break;
    }
//    output();

    int k = 0;
    rep(i,1,N){
        if(k) k--;

        if(rk[i] == 1) continue;
        int j = sa[rk[i] - 1];
        while(i + k <= N && j + k <= N && s[i + k] == s[j + k]) k++;
        ST[0][rk[i]] = k;
    }
    rep(i,1,19){
        rep(j,1,N){
            if(j + (1 << i) - 1 > N) break;
            ST[i][j] = min(ST[i - 1][j],ST[i - 1][j + (1 << (i - 1))]);
        }
    }
}

const Z i2 = Z(1) / 2;
void spsolve(){
    N = n;
    init();
    Z answer = Z(n) * (n + 1) * i2;
    rep(i,1,n) answer -= ST[0][i];
    printf("%d\n",answer.val());
}

int main(){
//    freopen("test.in","r",stdin);
//    freopen("test.out","w",stdout);
    scanf("%d%d",&n,&K);
    scanf("%s",s + 1);
    if(K == 1){
        spsolve();
        return 0;
    }
    rep(i,1,n) s[i + n] = s[i];
    N = 2 * n;
    init();
    Z answer = 0;
    for(int l = 1,r;l <= N;l = r + 1){
        r = l;
        while(r < N && ST[0][r + 1] >= n) r++;
        if(l == r){
            if(sa[l] > n) answer += N - sa[l] + 1 - ST[0][l];
            else answer += Z(n) * K - sa[l] + 1 - ST[0][l];
            continue;
        }
        int pos = sa[l];
        rep(i,l,r) chkmin(pos,sa[i]);
        answer += Z(n) * K - pos + 1 - ST[0][l];
//        printf("[%d,%d]\n",l,r);
    }
    printf("%d\n",answer.val());
	return 0;
}