#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;


const int MOD = 998244353;

int add(int a, int b) {
  if (a + b < MOD)
    return a + b;
  return a + b - MOD;
}

int sub(int a, int b) {
  if (a >= b)
    return a - b;
  return a + MOD - b;
}

int mul(int a, int b) {
  return a * 1ll * b % MOD;
}

const int MAXSZ = 6'000'600;
const int ALPHA = 10;

int go[MAXSZ][ALPHA];
int len[MAXSZ];
int suff[MAXSZ];
int nodes_cnt = 0;

int node() {
  fill(go[nodes_cnt], go[nodes_cnt] + ALPHA, -1);
  len[nodes_cnt] = 0;
  suff[nodes_cnt] = -1;
  ++nodes_cnt;
  return nodes_cnt - 1;
}

int get_char_id(char c) {
  return c - '0';
}

string cur_s;

int push_back(int last, char c) {
  cur_s += c;
  while ((int)cur_s.size() < len[last] + 2 || cur_s[cur_s.size() - len[last] - 2] != c)
    last = suff[last];
  if (go[last][get_char_id(c)] == -1) {
    int new_v = node();
    go[last][get_char_id(c)] = new_v;
    len[new_v] = len[last] + 2;
    if (len[last] == -1) {
      suff[new_v] = 1; // even root
    } else {
      int new_suff = suff[last];
      while (new_suff != -1 && cur_s[cur_s.size() - len[new_suff] - 2] != c)
        new_suff = suff[new_suff];
      suff[new_v] = go[new_suff][get_char_id(c)];
    }
  }
  last = go[last][get_char_id(c)];
  return last;
}


const int K = 23;
int up[MAXSZ][K];
int vals[MAXSZ];
int small_suff[MAXSZ];

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  
  node(); // 0 - odd root
  node(); // 1 - even root
  suff[0] = -1;
  len[0] = -1;
  suff[1] = 0;
  len[1] = 0;

  int n;
  cin >> n;
  string s;
  cin >> s;
  //for (int i = 0; i < n; ++i)
  //  s += '0';

  //cin >> s;
  vector<int> states(2 * n);
  int last = 1;
  for (int i = 0; i < 2 * n; ++i) {
    last = push_back(last, s[i < n ? i : i - n]);
    states[i] = last;
  }
  for (int i = 0; i < nodes_cnt; ++i)
    up[i][0] = suff[i];
  up[0][0] = 0;
  for (int j = 1; j < K; ++j) {
    for (int i = 0; i < nodes_cnt; ++i)
      up[i][j] = up[up[i][j - 1]][j - 1];
  }
  for (int i = 2; i < nodes_cnt; ++i) {
    if (len[i] <= n)
      small_suff[i] = i;
    else
      small_suff[i] = small_suff[suff[i]];
  }

  auto add_from_len = [&](int v, int from) {
    v = small_suff[v]; // len <= n
    if (len[v] < from)
      return;
    ++vals[v];
    if (from == 1) {
      v = 1;
    } else {
      for (int j = K - 1; j >= 0; --j) {
        if (len[up[v][j]] >= from)
          v = up[v][j];
      }
      v = up[v][0];
    }
    --vals[v];
  };
  for (int i = 0; i < 2 * n; ++i) {
    add_from_len(states[i], i < n ? 1 : i - n + 2);
  }
  for (int v = nodes_cnt - 1; v > 0; --v) {
    vals[suff[v]] += vals[v];
  }
  int ans = 0;
  for (int v = 2; v < nodes_cnt; ++v) {
    ans = add(ans, mul(mul(vals[v], vals[v]), len[v]));
  }
  cout << ans << '\n';
  return 0;
}