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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using static Sample.Settings;
using static System.Math;

namespace Sample
{
    public sealed class Program : BaseProgram
    {
        public static void Main(string[] args)
        {
            using (var sc = new SetConsole()) { Solve(); }
        }
        public static void Solve()
        {
            var n = GetNumber<int>();
            var a = GetArray<byte>();

            var bs = Enumerable.Repeat(0, n + 1).ToList();
            for (int i = n / 2 + 1; i <= n; i++)
            {
                bs[i] = a[i - 1];
            }

            for (int i = n / 2; i >= 1; i--)
            {
                int j = i;
                int count = 0;
                var mult = 2;
                j = i * mult++;

                while (j <= n)
                {
                    count += bs[j];
                    j = i * mult++;
                }

                if (a[i - 1] == 0 && count %  2 == 0)
                {
                    bs[i] = 0;
                }
                else if (a[i - 1] == 1 && count % 2 == 0)
                {
                    bs[i] = 1;
                }
                else if (a[i - 1] == 1 && count % 2 == 1)
                {
                    bs[i] = 0;
                }
                else if (a[i - 1] == 0 && count % 2 == 1)
                {
                    bs[i] = 1;
                }
            }

            var result = bs.Where(b => b != 0).ToList();
            Write(result.Count);
            if (result.Any())
            {
                Write(result.StringJoin(" "));
            }            
        }
    }

    public class BaseProgram
    {
        protected static void Write<T>(T str) => Console.WriteLine(str);
        protected static string GetString() => Console.ReadLine();
        protected static T GetNumber<T>() where T : IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
        {
            var str = GetString();
            if (str == null) { throw new NullReferenceException("標準入力がnullです Solveメソッド内の解答コードが間違っています"); }

            var t = typeof(T);
            if ((t == typeof(byte)))
            {
                return (T)(object)str.ToByte();
            }
            else if (t == typeof(int))
            {
                return (T)(object)str.ToInt();
            }
            else if (t == typeof(long))
            {
                return (T)(object)str.ToLong();
            }
            else if (t == typeof(double))
            {
                return (T)(object)str.ToDouble();
            }
            throw new NotSupportedException();
        }
        protected static T[] GetArray<T>() where T : IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
        {
            var str = GetString();
            if (str == null) { throw new NullReferenceException("標準入力がnullです Solveメソッド内の解答コードが間違っています"); }
            return str.ToArray<T>();
        }
        protected static void Swap<T>(ref T item1, ref T item2)
        {
            var tmp = item1;
            item1 = item2;
            item2 = tmp;
        }
        protected class SetConsole : IDisposable
        {
            readonly StreamWriter sw = new StreamWriter(Console.OpenStandardOutput());
            public SetConsole()
            {
                sw.AutoFlush = false;
                Console.SetOut(sw);
            }
            public void Dispose()
            {
                Console.Out.Flush();
                sw.AutoFlush = true;
                Console.SetOut(sw);
            }
        }
    }
    static class ExtentionsLibrary
    {
        public static List<T> CopyList<T>(this IReadOnlyList<T> list) => CopyArray(list.ToArray()).ToList();
        public static T[] CopyArray<T>(this T[] array)
        {
            var newArray = new T[array.Length];
            Array.Copy(array, newArray, array.Length);
            return newArray;
        }
        public static T[,] CopyArray<T>(this T[,] array)
        {
            var firstDimentionLength = array.GetLength(0);
            var secondDimentionLength = array.GetLength(1);
            var newDArray = new T[firstDimentionLength, secondDimentionLength];
            Array.Copy(array, newDArray, firstDimentionLength * secondDimentionLength);
            return newDArray;
        }
        public static T[] ToArray<T>(this string str) where T : IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
        {
            if (typeof(T) == typeof(string)) { return (T[])(object)str.Split(); }

            return str.ConvertEnumerator<T>().ToArray();
        }
        public static IEnumerable<T> ConvertEnumerator<T>(this string str) where T : IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
        {
            var t = typeof(T);
            if (t == typeof(byte))
            {
                return (IEnumerable<T>)str.Split().Select(byte.Parse);
            }
            if (t == typeof(int))
            {
                return (IEnumerable<T>)str.Split().Select(int.Parse);
            }
            if (t == typeof(long))
            {
                return (IEnumerable<T>)str.Split().Select(long.Parse);
            }
            if (t == typeof(double))
            {
                return (IEnumerable<T>)str.Split().Select(double.Parse);
            }
            if (t == typeof(BigInteger))
            {
                return (IEnumerable<T>)str.Split().Select(BigInteger.Parse);
            }
            throw new NotSupportedException();
        }
        public static byte ToByte(this string str) => byte.Parse(str);
        public static byte ToByte(this char chr) => byte.Parse(chr.ToString());
        public static int ToInt(this string str) => int.Parse(str);
        public static int ToInt(this char chr) => int.Parse(chr.ToString());
        public static long ToLong(this string str) => long.Parse(str);
        public static double ToDouble(this string str) => double.Parse(str);
        public static BigInteger ToBigInteger(this string str) => BigInteger.Parse(str);
        public static DateTime ToDateTime(this string str) => DateTime.Parse(str);
        public static string StringJoin(this object[] array, string separator) => string.Join(separator, array);
        public static string StringJoin<T>(this IEnumerable<T> collection, string separator) => string.Join(separator, collection.Select(c => c.ToString()));
    }
    public class PriorityQueue<T> : IEnumerable<T> where T : IComparable<T>
    {
        private readonly Priority priority;
        private List<T> heap = new List<T> { default(T) };

        private PriorityQueue() { }
        public PriorityQueue(Priority p)
        {
            priority = p;
        }
        public int Count() => heap.Count - 1;
        public T Peek()
        {
            if (Count() <= 0) { throw new Exception("要素が空です"); }
            return heap[1];
        }
        public T Dequeue()
        {
            if (Count() <= 0) { throw new Exception("要素が空です"); }

            var max = heap[1];
            heap[1] = heap[heap.Count - 1];
            heap.RemoveAt(heap.Count - 1);
            MaxHeapify(1);
            return max;
        }
        public void Enqueue(T key)
        {
            HeapIncreaseKey(key);
        }
        public void EnqueueRange(IEnumerable<T> keys)
        {
            foreach (var key in keys) { HeapIncreaseKey(key); }
        }
        public void Clear()
        {
            heap = new List<T>() { default(T) };
        }
        private void MaxHeapify(int i)
        {
            int largest;
            int l = Left(i);
            int r = Right(i);

            if (l <= heap.Count - 1 && Compare(heap[i], heap[l]) < 0)
            {
                largest = l;
            }
            else
            {
                largest = i;
            }
            if (r <= heap.Count - 1 && Compare(heap[r] ,heap[largest]) > 0)
            {
                largest = r;
            }

            if (largest != i)
            {
                var temp = heap[i];
                heap[i] = heap[largest];
                heap[largest] = temp;
                MaxHeapify(largest);
            }
        }
        private void HeapIncreaseKey(T key)
        {
            heap.Add(key);
            int lastIndex = heap.Count - 1;
            while (lastIndex > 1 && Compare(heap[Parent(lastIndex)], heap[lastIndex]) < 0)
            {
                var temp = heap[lastIndex];
                heap[lastIndex] = heap[Parent(lastIndex)];
                heap[Parent(lastIndex)] = temp;
                lastIndex = Parent(lastIndex);
            }
        }
        private static int Parent(int i) => i / 2;
        private static int Left(int i) => i * 2;
        private static int Right(int i) => i * 2 + 1;
        private int Compare(T x, T y) => priority == Priority.Larger ? x.CompareTo(y) : y.CompareTo(x);
        IEnumerator<T> IEnumerable<T>.GetEnumerator() => heap.Skip(1).GetEnumerator();
        public IEnumerator GetEnumerator()
        {
            return heap.Skip(1).GetEnumerator();
        }
    }
    public class Settings
    {
        public enum Priority : byte
        {
            Smaller = 0,
            Larger = 1
        }
    }
}