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 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define MOD 998244353

struct test {
    long long N;
    char X[2*100000+1];
    long long a;
} testdata[] = {
    {
        3,
        "111",
        40
    },
    {
        6,
        "110101",
        616
    },
    {
        30,
        "001110011011011101010111011100",
        549320998
    },
    {
        9,
        "101111111",
        6832
    },
};

#define CHAR_BIT    8
void printb(unsigned long long v) {
    unsigned long long mask = (long long)1 << (sizeof(v) * CHAR_BIT - 1);
    do putchar(mask & v ? '1' : '0');
    while (mask >>= 1);
}

int
divider(long long N, long long *div, int isFilter)
{
    int i, stop;
    int j=0;
    long long n = 2 * N;

    stop = n;
    
    for (i=2; i<stop; i++) {
        if (n%i==0) {
            if (isFilter==0 || ((i&1)==0 && ((n/i)&1)==1)) {
                div[j++] = i;
            }
        }
    }
    return j;
}

void
solver(long long N, char *X)
{
    long long div[2*100000], tdiv;
    int subTotal[2*100000];
    int numDiv;
    int i, j, k;
    long long targetNum = 0, subNum;
    long long result = 0;
    char bit;
    
    bzero(div, sizeof(div));
    bzero(subTotal, sizeof(subTotal));
    numDiv = divider(N, div, 1);

    for (i=0; i<N; i++) {
        targetNum = targetNum<< 1;
        targetNum = targetNum % MOD;
        targetNum |= X[i]-'0';
    }
    targetNum++;

    for (i=0; i<numDiv; i++) {
        subNum = 0;
        tdiv = div[i]/2;
        for(j=0; j<tdiv; j++) {
            subNum = subNum<< 1;
            subNum = subNum % MOD;
            subNum |= X[j]-'0';
        }
        for(k=j; k<strlen(X); k++) {
            if ((k/tdiv)&1) {
                if (1-X[k%tdiv]+2*'0' != X[k]) {
                    if (X[k]=='1')
                        subNum++;
                    break;
                }
            }
            else {
                if (X[k%tdiv] != X[k]) {
                    if (X[k]=='1')
                        subNum++;
                    break;
                }
            }
        }

        for (j=0; j<i; j++) {
            if (div[i]%div[j]==0 && (div[i]/div[j])&1==1) {
                subNum -= subTotal[div[j]];
            }
        }
        subTotal[div[i]] = subNum;
        targetNum -= subNum;
        result = (result + subNum * div[i])%MOD;

//        printf("%lld: %lld -> %lld\n", div[i], subNum, result);
    }
//    printf("targetNum %lld\n", targetNum);
    result = (result + (targetNum * 2 * N)) % MOD;
    
    printf("%lld\n", result);
}

int
main(int argc, char *argv[])
{
    int i;
    int N;
    char X[2*100000+1];

//    for (i=2; i<4; i++) {
//        solver(testdata[i].N, testdata[i].X);
//        printf("ans %lld\n", testdata[i].a);
//    }
    scanf("%d", &N);
    scanf("%s", X);
    solver(N, X);
    return 0;
}