#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
#define int long long
#define ll long long
#define eps LDBL_EPSILON
#define mod (ll)998244353
#define INF LLONG_MAX/10
#define P pair<int,int>
#define prique priority_queue
using namespace std;
int gcd(int a, int b) {
    if (!b)return a;
    return gcd(b, a % b);
}
int lcm(int a, int b) {
    return a / gcd(a, b) * b;
}
int mypow(int a, int b) {
    if (!b)return 1;
    if (b % 2)return mypow(a, b - 1) * a;
    int memo = mypow(a, b / 2);
    return memo * memo;
}
int modpow(int a, int b) {
    if (!b)return 1;
    if (b % 2)return modpow(a, b - 1) * a % mod;
    int memo = modpow(a, b / 2);
    return memo * memo % mod;
}
class RollingHash {
    string s;
    int n, m, base;
    int* has;
    int mypow(int x, int y) {
        if (!y)return 1;
        if (y % 2)return this->mypow(x, y - 1) * x % m;
        int memo = this->mypow(x, y / 2);
        return memo * memo % m;
    }
public:
    RollingHash() {}
    RollingHash(string s, int m, int b) { init(s, m, b); }
    ~RollingHash() { delete[] has; }
    void init(string s, int m, int b) {
        n = s.size();
        has = new int[n];
        base = b;
        this->s = s;
        this->m = m;
        rep(i, n) {
            has[i] = (int)s[i];
            if (i)has[i] += base * has[i - 1] % m;
            has[i] %= m;
        }
    }
    int query(int a, int b) {
        assert(!(a >= b || a < 0 || n < b));
        return (has[b - 1] - this->mypow(base, b - a) * (!a ? 0 : has[a - 1]) % m + m) % m;
    }
};
class mycomplex {
    double realvalue, imagvalue;
public:
    mycomplex() :realvalue(0), imagvalue(0) {}
    mycomplex(double realvalue, double imagvalue) : realvalue(realvalue), imagvalue(imagvalue) {}
    mycomplex(double realvalue) : realvalue(realvalue), imagvalue(0) {}
    mycomplex(complex<double> c) :realvalue(c.real()), imagvalue(c.imag()) {}
    mycomplex(const mycomplex& rhs) :realvalue(rhs.realvalue), imagvalue(rhs.imagvalue) {}
    double real()const { return this->realvalue; }
    double imag()const { return this->imagvalue; }
    double abs() { return hypot(realvalue, imagvalue); }
    mycomplex& operator=(const mycomplex& obj) {
        if (this != &obj) {
            this->realvalue = obj.realvalue;
            this->imagvalue = obj.imagvalue;
        }
        return *this;
    }
    mycomplex& operator=(mycomplex&& obj)noexcept {
        if (this != &obj) {
            this->realvalue = exchange(obj.realvalue, 0);
            this->imagvalue = exchange(obj.imagvalue, 0);
        }
        return *this;
    }
    mycomplex& operator+=(const mycomplex& rhs) {
        this->realvalue += rhs.realvalue;
        this->imagvalue += rhs.imagvalue;
        return *this;
    }
    friend mycomplex operator+(mycomplex lhs, const mycomplex& rhs) {
        lhs += rhs;
        return lhs;
    }
    mycomplex& operator-=(const mycomplex& rhs) {
        this->realvalue -= rhs.realvalue;
        this->imagvalue -= rhs.imagvalue;
        return *this;
    }
    mycomplex& operator-=(const double& rhs) {
        this->realvalue -= rhs;
        return *this;
    }
    friend mycomplex operator-(mycomplex lhs, const mycomplex& rhs) {
        lhs -= rhs;
        return lhs;
    }
    mycomplex& operator*=(const mycomplex& rhs) {
        double pastreal = this->realvalue;
        this->realvalue = this->realvalue * rhs.realvalue - this->imagvalue * rhs.imagvalue;
        this->imagvalue = pastreal * rhs.imagvalue + rhs.realvalue * this->imagvalue;
        return *this;
    }
    friend mycomplex operator*(mycomplex lhs, const mycomplex& rhs) {
        lhs *= rhs;
        return lhs;
    }
    mycomplex& operator/=(const mycomplex& rhs) {
        *this *= mycomplex(rhs.real(), -rhs.imag());
        double dnm = rhs.real() * rhs.real() - rhs.imag() * rhs.imag();
        this->realvalue /= dnm;
        this->imagvalue /= dnm;
        return *this;
    }
    friend mycomplex operator/(mycomplex lhs, const mycomplex& rhs) {
        lhs /= rhs;
        return lhs;
    }
};
class FastFourierTransform {
private:
    static void dft(vector<mycomplex>& func, int inverse) {
        int sz = func.size();
        if (sz == 1)return;
        vector<mycomplex> veca, vecb;
        rep(i, sz / 2) {
            veca.push_back(func[2 * i]);
            vecb.push_back(func[2 * i + 1]);
        }
        dft(veca, inverse); dft(vecb, inverse);
        mycomplex now = 1, zeta = polar(1.0, inverse * 2.0 * acos(-1) / sz);
        rep(i, sz) {
            func[i] = veca[i % (sz / 2)] + now * vecb[i % (sz / 2)];
            now *= zeta;
        }
    }
public:
    template<typename T>
    static vector<double> multiply(vector<T> f, vector<T> g) {
        vector<mycomplex> nf, ng;
        int sz = 1;
        while (sz < f.size() + g.size())sz *= 2;
        nf.resize(sz); ng.resize(sz);
        rep(i, f.size()) {
            nf[i] = f[i];
            ng[i] = g[i];
        }
        dft(nf, 1);
        dft(ng, 1);
        rep(i, sz)nf[i] *= ng[i];
        dft(nf, -1);
        vector<double> res;
        rep(i, sz)res.push_back(nf[i].real() / sz);
        return res;
    }
};
string func(string s) {
    string res;
    rep(i, s.size()) {
        if (s[i] == '0')res += '1';
        else res += '0';
    }
    return res;
}
int n;
string x;
signed main() {
    cin >> n >> x;
    vector<int> odd;
    for (int i = 1; i <= n; i += 2) {
        if (n % i == 0)odd.push_back(i);
    }
    reverse(odd.begin(), odd.end());
    vector<P> vec;
    for (int i : odd) {
        string t = x.substr(0, n / i);
        string r = func(t);
        string c;
        rep(j, i) {
            if (j % 2)c += r;
            else c += t;
        }
        bool f = false;
        if (c <= x)f = true;
        int cnt = 0;
        rep(j, n / i) {
            if (t[j] == '1') {
                cnt += modpow(2, n / i - 1 - j);
                cnt %= mod;
            }
        }
        if (f) {
            cnt++;
            cnt %= mod;
        }
        vec.push_back(make_pair(cnt, n / i * 2 % mod));
    }
    int ans = 0;
    rep(i, vec.size()) {
        ans += vec[i].first * vec[i].second % mod;
        ans %= mod;
        for (int j = i + 1; j < vec.size(); j++) {
            if (vec[j].second % vec[i].second == 0) {
                vec[j].first -= vec[i].first;
                vec[j].first += mod;
                vec[j].first %= mod;
            }
        }
    }
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 1288