Problem:
Score : 400 points

Problem Statement

There are N empty boxes arranged in a row from left to right.
The integer i is written on the i-th box from the left (1 \leq i \leq N).

For each of these boxes, Snuke can choose either to put a ball in it or to put nothing in it.

We say a set of choices to put a ball or not in the boxes is good when the following condition is satisfied:

For every integer i between 1 and N (inclusive), the total number of balls contained in the boxes with multiples of i written on them is congruent to a_i modulo 2.

Does there exist a good set of choices? If the answer is yes, find one good set of choices.

Constraints

All values in input are integers.

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

a_i is 0 or 1.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

If a good set of choices does not exist, print -1.

If a good set of choices exists, print one such set of choices in the following format:

M
b_1 b_2 ... b_M

where M denotes the number of boxes that will contain a ball, and b_1,\ b_2,\ ...,\ b_M are the integers written on these boxes, in any order.

Sample Input 1

3
1 0 0

Sample Output 1

1
1

Consider putting a ball only in the box with 1 written on it.

There are three boxes with multiples of 1 written on them: the boxes with 1, 2, and 3. The total number of balls contained in these boxes is 1.

There is only one box with a multiple of 2 written on it: the box with 2. The total number of balls contained in these boxes is 0.

There is only one box with a multiple of 3 written on it: the box with 3. The total number of balls contained in these boxes is 0.

Thus, the condition is satisfied, so this set of choices is good.

Sample Input 2

5
0 0 0 0 0

Sample Output 2

0

Putting nothing in the boxes can be a good set of choices.

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

use std::collections::HashMap;
use std::collections::VecDeque;
use std::usize::MAX;

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
  }

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};
    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
  }

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };
    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };
    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };
    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };
    // 3
    // 1 2
    // 1 3
    // 1 4
    // のようなタイプ
    ($next:expr, [ $t:tt ]) => {{
        let len = read_value!($next, usize);
        (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    }};
    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
  }

// 最大公約数
fn gcd(a: u64, b: u64) -> u64 {
    let mut aa: u64 = if a > b { a } else { b };
    let mut bb: u64 = if a > b { b } else { a };
    while bb != 0 {
        let tmp = bb;
        bb = aa % tmp;
        aa = tmp;
    }
    return aa;
}

// 最小公倍数
fn lcm(a: u64, b: u64) -> u64 {
    a / gcd(a, b) * b
}

// DFS,BFS
fn BFS() {
    let mut searchResult = vec![vec![MAX; 100]; 100];
    let mut q: VecDeque<(usize, usize)> = VecDeque::new();
    q.push_front((0, 0));
    searchResult[0][0] = 0;

    let moves = [(1, 0), (-1, 0), (0, 1), (0, -1)];

    while !q.is_empty() {
        let pos = q.pop_back().unwrap(); // これがpop_frontならstackになって深さ優先になる
        for m in moves.iter() {
            let dx: i64 = pos.0 as i64 + m.0;
            let dy: i64 = pos.1 as i64 + m.1;
            if dx >= 0
                && dx < 100
                && dy >= 0
                && dy < 100
                && searchResult[dx as usize][dy as usize] == MAX
            {
                q.push_front((dx as usize, dy as usize));
                searchResult[dx as usize][dy as usize] = searchResult[pos.0][pos.1] + 1;
            }
        }
    }
}

// 文字列操作

const LARGE_PRIME: u64 = 1_000_000_007;

fn inverse_mod(element: u64, modulo: u64) -> u64 {
    // フェルマーの小定理からpが素数なら a^(p-1) = 1
    // よってa*a^(p-2) = 1 より a^(p-2)がaの逆元

    fn power(base: u64, exp: u64, modulo: u64) -> u64 {
        if exp == 0 {
            return 1;
        } else if exp & 1 == 0 {
            return (power(base, exp / 2, modulo) % modulo).pow(2) % modulo;
        } else {
            return power(base, exp - 1, modulo) % modulo * base % modulo;
        }
    }

    power(element, modulo - 2, modulo) % modulo
}

fn combination_mod(m: u64, n: u64, modulo: u64) -> u64 {
    // m C n = m! / ( n! * (m - n)! )
    //       = m*(m-1)*(m-2)*...*(m-n+1)/n!
    //       = m*(m-1)*(m-2)*...*(m-n+1) * (n!)^-1

    let mut numerator = 1;
    for i in 0..n {
        numerator *= m - i;
        numerator %= modulo;
    }

    // (m-n)!
    let mut element = 1;
    for j in 1..(n + 1) {
        element *= j;
        element %= modulo;
    }

    numerator * inverse_mod(element, modulo) % modulo
}

fn solve() {
    input! {
        n: usize,
        a:[usize;n]
    }

    let mut ball = vec![false; n];
    for i in (0..n).rev() {
        let mut num = i + 1;
        let mut count = 0;

        while num <= n {
            if ball[num - 1] {
                count += 1;
            }
            num += num;
        }

        if a[i] != count % 2 {
            ball[i] = true;
        }
    }

    //println!("{:?}", ball);

    let mut m = 0;
    for i in 0..n {
        if ball[i] {
            m += 1;
        }
    }

    println!("{}", m);
    if m > 0 {
        for i in 0..n {
            if ball[i] {
                print!("{}", i + 1);
                if i != n - 1 {
                    print!(" ");
                }
            };
        }
        println!();
    }
}

fn main() {
    let thd = std::thread::Builder::new().stack_size(104_857_600);
    thd.spawn(|| solve()).unwrap().join().unwrap();
}