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

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using V = vector<T>;
template <class T> using VV = vector<vector<T>>;

using ll = int64_t;

template <class F> struct ycr {
	F f;
	template <class T> explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... A> decltype(auto) operator()(A&&... as) {
		return f(ref(*this), forward<A>(as)...);
	}
};
template <class F> decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

template <int K, class S> struct eertree {
	struct N {
		int suf, anc, l, r;
		array<int, K> ch;
		int len() const { return r-l; }
	};
	V<N> nodes;
	int cur;
	S buf;
	eertree(int alloc = 0) {
		if (alloc > 2) {
			nodes.reserve(alloc);
		}
		nodes.push_back({-1, -1, 1, 0, {}});
		nodes.push_back({0, -1, 0, 0, {}});
		reset();
	}
	void reset() {
		buf.clear();
		cur = 1;
	}

	int dist(int v) {
		return nodes[v].suf <= 0 ? -1 : nodes[v].len() - nodes[nodes[v].suf].len();
	}
	template <class A> int extend(A a) {
		int i = int(buf.size());
		buf.push_back(a);
		auto works = [&](int v) -> bool {
			int l = i - nodes[v].len();
			return l > 0 && buf[l-1] == buf[i];
		};
		while (!works(cur)) cur = nodes[cur].suf;
		if (!nodes[cur].ch[buf[i]]) {
			int d = nodes[cur].suf;
			if (d != -1) {
				while (!works(d)) d = nodes[d].suf;
			}
			int e = (d == -1 ? 1 : nodes[d].ch[buf[i]]);
			int f = nodes[cur].ch[buf[i]] = int(nodes.size());
			nodes.push_back({e, e, i - nodes[cur].len() - 1, i + 1, {}});
			if (dist(e) == dist(f)) nodes[f].anc = nodes[e].anc;
		}
		return cur = nodes[cur].ch[buf[i]];
	}

	const N& operator [] (int i) const {
		return nodes[i];
	}
};

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);

	int N;
	cin >> N;
	string S;
	cin >> S;

	eertree<10, V<int>> et(2*N+10);
	for (int i = 0; i < N; i++) {
		int a = int(S[i] - '0');
		assert(0 <= a && a < 10);
		et.extend(a);
	}
	V<int> locs(N);
	for (int i = 0; i < N; i++) {
		int a = int(S[i] - '0');
		assert(0 <= a && a < 10);
		locs[i] = et.extend(a);
	}

	int num_et = int(et.nodes.size());
	V<int> dp(num_et);
	for (int v : locs) {
		dp[v]++;
	}

	constexpr int MOD = 998244353;
	auto add = [&](int& a, int b) -> void {
		a += b;
		if (a >= MOD) a -= MOD;
	};

	int ans = 0;
	for (int v = num_et-1; v >= 2; v--) {
		add(dp[et[v].suf], dp[v]);
		int len = et[v].len();
		if (len <= N) {
			int cur = int(ll(dp[v]) * dp[v] % MOD * len % MOD);
			add(ans, cur);
		}
	}
	cout << ans << '\n';

	return 0;
}