Problem:
Score : 800 points

Problem Statement

Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.

Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)

Constraints

1 \leq N \leq 2\times 10^5

0 \leq X < 2^N

X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
X

Output

Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.

Sample Input 1

3
111

Sample Output 1

40

For example, for k=3, the operation changes k as follows: 1,0,4,6,7,3. Therefore the answer for k=3 is 6.

Sample Input 2

6
110101

Sample Output 2

616

Sample Input 3

30
001110011011011101010111011100

Sample Output 3

549320998

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>

using namespace std;

#define SZ(x) (int)(x.size())
#define REP(i, n) for(int i=0;i<(n);++i)
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RREP(i, n) for(int i=(int)(n);i>=0;--i)
#define RFOR(i, a, b) for(int i=(int)(a);i>=(int)(b);--i)
#define ALL(a) (a).begin(),(a).end()
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl
#define DEBUG(x) cerr<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<< endl;

using ll = long long;
#define int ll
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;

const double eps = 1e-8;
const ll MOD = 998244353;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;

template <typename T1, typename T2>
bool chmax(T1 &a, const T2 &b) {
  if(a < b) {a = b; return true;}
  return false;
}

template <typename T1, typename T2>
bool chmin(T1 &a, const T2 &b) {
  if(a > b) {a = b; return true;}
  return false;
}

template<typename T1, typename T2>
ostream& operator<<(ostream &os, const pair<T1, T2> p) {
  os << p.first << ":" << p.second;
  return os;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  REP(i, SZ(v)) {
    if(i) os << " ";
    os << v[i];
  }
  return os;
}

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);

  int n; cin >> n;
  string s; cin >> s;

  vi v;
  for(ll i=1;i*i<=n;++i) {
    if(n % i == 0) {
      if(n/i % 2) v.push_back(i);
      if(i*i != n && i%2) v.push_back(n/i);
    }
  }
  int sz = SZ(v);
  sort(ALL(v));
  map<int, int> hojo;
  ll ans = 0;

  REP(i, sz) {
    int d = v[i];
    //cout << d << endl;
    vvll dp(n+1, vll(2));
    dp[0][1] = 1;
    REP(j, d) {
      if(s[j] == '1') {
        dp[j+1][1] = dp[j][1];
        dp[j+1][0] = dp[j][1] + 2 * dp[j][0];
        dp[j+1][0] %= MOD;
      } else {
        dp[j+1][1] = dp[j][1];
        dp[j+1][0] = 2 * dp[j][0];
        dp[j+1][0] %= MOD;
      }
      //cout << dp[j] << endl;
    }

    FOR(j, d, n) {
      int nowval = s[j%d]-'0';
      if(j/d%2) nowval = !nowval;
      char c = nowval+'0';
      if(s[j] == '0') {
        if(c == '0') {
          dp[j+1][1] = dp[j][1];
        } else {
        }
      } else {
        if(c == '0') {
          dp[j+1][0] = dp[j][1];
        } else {
          dp[j+1][1] = dp[j][1];
        }
      }

      dp[j+1][0] += dp[j][0];
      dp[j+1][0] %= MOD;
      //cout << dp[j] << endl;
    }
    //cout << dp[n] << endl;

    ll add = dp[n][0] + dp[n][1];
    add %= MOD;

    for(auto &e: hojo) {
      if(d % e.first == 0) {
        add += MOD - e.second;
        add %= MOD;
      }
    }
    hojo[d] = add;

    add *= 2 * d;
    add %= MOD;
    ans += add;
    ans %= MOD;
  }
  cout << ans << endl;
}