#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#include <experimental/iterator>
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

struct PalindromicTree {
  struct node {
    int nxt[10], f, len;
    int cnt, num;
    node(int l = 0)
      : nxt {}, f(0), len(l), cnt(0), num(0) {}
  };
  vector<node> st;
  vector<char> s;
  int last, n;
  void init() {
    st.clear(); s.clear();
    last = 1; n = 0;
    st.push_back(0); st.push_back(-1);
    st[0].f = 1; s.push_back(-1);
  }
  int getFail(int x) {
    while (s[n - st[x].len - 1] != s[n])
      x = st[x].f;
    return x;
  }
  void add(int c) {
    s.push_back(c -= '0');
    ++n;
    int cur = getFail(last);
    if (!st[cur].nxt[c]) {
      int now = (int)st.size();
      st.push_back(st[cur].len + 2);
      st[now].f = st[getFail(st[cur].f)].nxt[c];
      st[cur].nxt[c] = now;
      st[now].num = st[st[now].f].num + 1;
    }
    last = st[cur].nxt[c];
    // ++st[last].cnt;
  }
  void dpcnt() {
    for (int i = (int)st.size() - 1; i >= 0; i--)
      st[st[i].f].cnt += st[i].cnt;
  }
  void clear_cnt() {
    for (int i = (int)st.size() - 1; i >= 0; i--)
      st[i].cnt = 0;
  }
  int size() { return st.size() - 2; }
} pt;

const int mod = 998244353;
int mul(int64_t a, int64_t b) {
  return static_cast<int>(a * b % mod);
}
int add(int a, int b) {
  return a + b >= mod ? a + b - mod : a + b;
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n;
  string s;
  cin >> n >> s;

  pt.init();
  vector<int> F, S;
  for (int i = 0; i < n; i++) {
    pt.add(s[i]);
    F.push_back(pt.last);
    S.push_back(pt.last);
  }
  for (int i = 0; i < n; i++) {
    pt.add(s[i]);
    S.push_back(pt.last);
  }

  pt.clear_cnt();
  for (int x : S)
    pt.st[x].cnt += 1;
  pt.dpcnt();
  vector<int> cnt(pt.st.size());
  for (size_t i = 0; i < pt.st.size(); i++) {
    cnt[i] += pt.st[i].cnt;
  }

  pt.clear_cnt();
  for (int x : F)
    pt.st[x].cnt += 1;
  pt.dpcnt();
  for (size_t i = 0; i < pt.st.size(); i++) {
    cnt[i] -= pt.st[i].cnt;
  }

  int ans = 0;
  for (size_t i = 0; i < pt.st.size(); i++) {
    int len = pt.st[i].len;
    if (len <= n && len > 0) {
      assert(cnt[i] >= 0 && cnt[i] <= n);
      ans = add(ans, mul(mul(cnt[i], cnt[i]), len));
      debug(cnt[i], len);
    }
  }
  cout << ans << '\n';

  return 0;
}