#include <bits/stdc++.h>

using namespace std;

constexpr int mod = 998244353;

struct PAM {
    static constexpr int N = 10;
    struct Node {
        int len;
        int link;
        int cnt;
        array <int, N> nxt;
        Node () : len {}, link {}, cnt {}, nxt {} {};
    };
    vector <Node> t;
    int suff;
    string s;
    PAM () {
        init ();
    }
    void init () {
        t.assign (2, Node ());
        t[0].len = -1;
        suff = 1;
        s.clear ();
    }
    int newNode () {
        t.emplace_back ();
        return t.size () - 1;
    }
    bool add (char c) {
        int pos = s.size ();
        s += c;
        int let = c - '0';
        int cur = suff, curlen = 0;
        while (true) {
            curlen = t[cur].len;
            if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) {
                break;
            }
            cur = t[cur].link;
        }
        if (t[cur].nxt[let]) {
            suff = t[cur].nxt[let];
            return false;
        }
        int num = newNode ();
        suff = num;
        t[num].len = t[cur].len + 2;
        t[cur].nxt[let] = num;
        if (t[num].len == 1) {
            t[num].link = 1;
            t[num].cnt = 1;
            return true;
        } 
        while (true) {
            cur = t[cur].link;
            curlen = t[cur].len;
            if (pos - 1 - curlen >= 0 && s[pos - 1 - curlen] == s[pos]) {
                t[num].link = t[cur].nxt[let];
                break;
            }
        }
        t[num].cnt = 1 + t[t[num].link].cnt;
        return true;
    }

    int cnt (int p) {
        return t[p].cnt;
    }
    int nxt (int p, int x) {
        return t[p].nxt[x];
    }
    int link (int p) {
        return t[p].link;
    } 
    int len (int p) {
        return t[p].len;
    }
    int size () {
        return t.size ();
    }
};

using i64 = long long;

void solve () {
    int n;
    cin >> n;
    
    string s;
    cin >> s;

    s = s + s;

    PAM pam;
    vector <int> v;
    for (auto c : s) {
        pam.add (c);
        v.push_back (pam.suff);
    }
    
    const int N = pam.size ();

    vector <int> f (N);
    for (auto x : v) {
        f[x] ++;
    }

    vector <vector <int>> e (N);
    for (int i = 2; i < N; i ++) {
        e[pam.link (i)].push_back (i);
    }

    vector <int> len (N);

    auto dfs = [&](auto &&self, int x) -> void {
        for (auto y : e[x]) {
            self (self, y);
            f[x] += f[y];
        }
        len[x] = pam.len (x);
    };
    dfs (dfs, 1);

    pam.init ();
    vector <int> v2;
    for (int i = 0; i < n; i ++) {
        pam.add (s[i]);
        v2.push_back (pam.suff);
    }
    
    const int M = pam.size ();

    vector <int> f2 (M);
    for (auto x : v2) {
        f2[x] ++;
    }

    vector <vector <int>> e2 (M);
    for (int i = 2; i < M; i ++) {
        e2[pam.link (i)].push_back (i);
    }

    auto dfs2 = [&](auto &&self, int x) -> void {
        for (auto y : e2[x]) {
            self (self, y);
            f2[x] += f2[y];
        }
    };
    dfs2 (dfs2, 1);

    i64 ans = 0;
    for (int i = 2; i < N; i ++) {
        if (len[i] > n) {
            continue;
        }
        if (i < M) {
            f[i] -= f2[i];
        }
        ans = (ans + 1LL * f[i] * f[i] % mod * len[i] % mod) % mod;
    }

    cout << ans << '\n';
}

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

    int T = 1;
    // cin >> T;

    while (T --) {
        solve ();
    }
}