#include "bits/stdc++.h"

using namespace std;
#ifdef _DEBUG
#define _GLIBCXX_DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif

#define int long long
#define ll long long
#define DBG 1
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define loop(n) rep(loop, (0), (n))
#define all(c) begin(c), end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
using pii = pair<int, int>;
// template<class T> ostream &operator<<(ostream &os,T &t){dump(t);return os;}
template <typename T, typename S>istream &operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
//template <typename T, typename S>ostream &operator<<(ostream &os, pair<T, S> &p) {os << p.first << " " << p.second;return os;}

template <typename T> void printvv(const vector<vector<T>> &v) {
	cerr << endl;
	rep(i, 0, v.size()) rep(j, 0, v[i].size()) {
		if (typeid(v[i][j]).name() == typeid(INF).name() and v[i][j] == INF) {
			cerr << "INF";
		}
		else
			cerr << v[i][j];
		cerr << (j == v[i].size() - 1 ? '\n' : ' ');
	}
	cerr << endl;
}

#ifndef _DEBUG
#define printvv(...)
#endif
void YES(bool f) { cout << (f ? "YES" : "NO") << endl; }
void Yes(bool f) { cout << (f ? "Yes" : "No") << endl; }
template <class T, class U>bool chmin(T& a, U b) { if (a > b) { a = b; return true; }return false; }
template <class T, class U>bool chmax(T& a, U b) { if (a < b) { a = b; return true; }return false; }

template <int MOD> struct ModInt {
	static const int Mod = MOD;
	unsigned x;
	ModInt() : x(0) {}
	ModInt(signed sig) {
		int sigt = sig % MOD;
		if (sigt < 0)
			sigt += MOD;
		x = sigt;
	}
	ModInt(signed long long sig) {
		int sigt = sig % MOD;
		if (sigt < 0)
			sigt += MOD;
		x = sigt;
	}
	int get() const { return (int)x; }

	ModInt &operator+=(ModInt that) {
		if ((x += that.x) >= MOD)
			x -= MOD;
		return *this;
	}
	ModInt &operator-=(ModInt that) {
		if ((x += MOD - that.x) >= MOD)
			x -= MOD;
		return *this;
	}
	ModInt &operator*=(ModInt that) {
		x = (unsigned long long)x * that.x % MOD;
		return *this;
	}
	ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }

	ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
	ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
	ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
	ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }

	ModInt inverse() const {
		signed a = x, b = MOD, u = 1, v = 0;
		while (b) {
			signed t = a / b;
			a -= t * b;
			std::swap(a, b);
			u -= t * v;
			std::swap(u, v);
		}
		if (u < 0)
			u += MOD;
		ModInt res;
		res.x = (unsigned)u;
		return res;
	}
};
template <int MOD> ostream &operator<<(ostream &os, const ModInt<MOD> &m) {
	return os << m.x;
}
template <int MOD> istream &operator>>(istream &is, ModInt<MOD> &m) {
	signed long long s;
	is >> s;
	m = ModInt<MOD>(s);
	return is;
};
// pow(mint(2), 1000) のように
template <int MOD> ModInt<MOD> pow(ModInt<MOD> a, unsigned long long k) {
	ModInt<MOD> r = 1;
	while (k) {
		if (k & 1)
			r *= a;
		a *= a;
		k >>= 1;
	}
	return r;
}

//#define int long long を使っても大丈夫
using mint = ModInt<998244353>;

// 5は1e9+7の原始根
// return g^x=a mod p
int modlog(int g, int a) {
	// g is a primitive root modulo mint::Mod
	// let x = i*n + j , n = sqrt(Mod)
	// g^j = a*inv(g^(i*n)) = a*(inv(g^n))^i
	//https://en.wikipedia.org/wiki/Baby-step_giant-step
	//http://sonickun.hatenablog.com/entry/2016/11/20/192743
	//https://cp-algorithms.com/algebra/discrete-log.html
	unordered_map<int, int> M;
	int n = sqrt(mint::Mod);
	ll cur = 1;
	for (int i = 0; i < n; i++, (cur *= g) %= mint::Mod) {
		M[cur] = i;
	}
	ll gn = cur;
	ll gn_inv = mint(gn).inverse().get();
	cur = 1;
	ll num = 0;
	while (1) {
		ll x = a * cur % mint::Mod;
		if (M.count(x)) return num + M[x];
		cur = cur * gn_inv%mint::Mod;
		num += n;
	}
}
int modlog(int g, mint a) { return modlog(g, a.get()); }


// nCrで用いる
vector<mint> fact, factinv;
// nCrで用いる 予め計算しておく
void nCr_compute_factinv(int N) {
	N = min(N, mint::Mod - 1);
	fact.resize(N + 1);
	factinv.resize(N + 1);
	fact[0] = 1;
	rep(i, 1, N + 1) fact[i] = fact[i - 1] * i;
	factinv[N] = fact[N].inverse();
	for (int i = N; i >= 1; i--)
		factinv[i - 1] = factinv[i] * i;
}
mint nCr(int n, int r) {
	if (n >= mint::Mod)
		return nCr(n % mint::Mod, r % mint::Mod) *
		nCr(n / mint::Mod, r / mint::Mod);
	return r > n ? 0 : fact[n] * factinv[n - r] * factinv[r];
}

mint nHr(int n, int r) { return r == 0 ? 1 : nCr(n + r - 1, r); }

//エラトステネスの篩
vector<char> eratos(int n) {
	vector<char> is_prime(n + 1, true);
	is_prime[0] = is_prime[1] = false;
	for (int i = 2; i * i <= n; i++)
		if (is_prime[i]) {
			int j = i + i;
			while (j <= n) {
				is_prime[j] = false;
				j += i;
			}
		}
	return is_prime;
}
//戻り値: n以下の素数
vector<int> get_primes(int n) {
	vector<char> is_prime = eratos(n);
	vector<int> primes;
	for (int i = 0; i < n + 1; i++)
		if (is_prime[i])
			primes.emplace_back(i);
	return primes;
}
//素因数分解
vector<int> prime_factorization(int x) {
	vector<int> primes = get_primes(sqrt(x)); //√x以下の素数について調べれば良い
	vector<int> factors;
	// xまでのeratosと同じ。ｘはgiven ｘまでの最大の素数。
	// だんだん左によってくる。だからsqrt(x)まででいい
	for (auto &p : primes) {
		while (x % p == 0) {
			x /= p;
			factors.emplace_back(p);
		}
	}
	if (x != 1)
		factors.emplace_back(x);
	return factors;
}

int nxt(int x, int N) {
	if (x & 1) {
		return (x >>= 1);
	}
	else {
		return (x >>= 1) + (1ll << (N - 1));
	}
}
int f(int n) {
	//using B = bitset<aaaa>;
	vector<int>ret;
	vector<int>visited(1ll << n);
	int ans = 0;
	rep(i, 0, (1ll << n)) {
		if (visited[i])continue;
		int x = i;
		int cnt = 0;
		set<int>st;
		vector<int>hoge;
		while (not st.count(x)) {
			visited[x] = 1;
			hoge.eb(x);
			st.insert(x);
			x = nxt(x, n);
		}
		ans += hoge.size()*hoge.size();
	}
	return ans;
}
void dfs(int idx, int x, vector<pii>&p, int n, vector<int>&hoge) {
	if (idx == p.size()) {
		int w = n / x;
		hoge.eb(w);
		return;
	}
	rep(i, 0, p[idx].second + 1) {
		dfs(idx + 1, x, p, n, hoge);
		x *= p[idx].first;
	}

}
//約数を求める 未ソート
vector<int> divisor(int x) {
	vector<int> ret;
	int i;
	for (i = 1; i * i < x; i++) {
		if (x % i)
			continue;
		ret.emplace_back(i);
		ret.emplace_back(x / i);
	}
	if (i * i == x)
		ret.emplace_back(i);
	return ret;
}
int solve(int n, string s) {
	auto hoge = divisor(2 * n);
	vector<int>w;
	for (auto x : hoge) {
		if (x % 2 == 0 and (2 * n / x) % 2 == 1) {
			w.eb(x);
		}
	}
	sort(all(w));
	dump(w);
	vector<mint>v;
	for (auto k : w) {
		int len = k / 2;
		string t = s.substr(0, len);
		string _t = t;
		for (auto& c : _t) {
			if (c == '0')c = '1';
			else c = '0';
		}
		mint x = 0;
		mint base = 1;
		rrep(i, 0, t.size()) {
			if (t[i] == '1') {
				x += base;
			}
			base *= 2;
		}
		x += 1;
		string z;
		rep(i, 0, n / len) {
			if (i & 1) {
				z += _t;
			}
			else {
				z += t;
			}
		}
		dump(k, len, t, _t, x, z);
		x -= z > s;
		dump(x);
		v.eb(x);
	}
	dump(v);
	dump(w);
	mint ans;
	rep(i, 0, v.size()) {
		dump(v[i], w[i]);
		ans += v[i] * w[i];
		dump(ans);
		rep(j, i + 1, v.size()) {
			if (w[j] % w[i] == 0) {
				v[j] -= v[i];
			}
		}
	}

	cout << ans << endl;

	return 0;

}



signed main(signed argc, char *argv[]) {
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout << fixed << setprecision(12);

	int N; cin >> N;
	string S; cin >> S;
	solve(N, S);

	return 0;
}


Measured memory_bytes: 1104