Bajtek, known for his unusual gifts, recently got an integer array x_0, x_1, …, x_{k-1}.

Unfortunately, after a huge array-party with his extraordinary friends, he realized that he'd lost it. After hours spent on searching for a new toy, Bajtek found on the arrays producer's website another array a of length n + 1. As a formal description of a says, a_0 = 0 and for all other i (1 ≤ i ≤ n) a_i = x_{(i-1)mod k} + a_{i-1}, where p mod q denotes the remainder of division p by q.

For example, if the x = [1, 2, 3] and n = 5, then:

  * a_0 = 0, 
  * a_1 = x_{0mod 3}+a_0=x_0+0=1, 
  * a_2 = x_{1mod 3}+a_1=x_1+1=3, 
  * a_3 = x_{2mod 3}+a_2=x_2+3=6, 
  * a_4 = x_{3mod 3}+a_3=x_0+6=7, 
  * a_5 = x_{4mod 3}+a_4=x_1+7=9. 



So, if the x = [1, 2, 3] and n = 5, then a = [0, 1, 3, 6, 7, 9].

Now the boy hopes that he will be able to restore x from a! Knowing that 1 ≤ k ≤ n, help him and find all possible values of k — possible lengths of the lost array.

Input

The first line contains exactly one integer n (1 ≤ n ≤ 1000) — the length of the array a, excluding the element a_0.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^6).

Note that a_0 is always 0 and is not given in the input.

Output

The first line of the output should contain one integer l denoting the number of correct lengths of the lost array.

The second line of the output should contain l integers — possible lengths of the lost array in increasing order.

Examples

Input

5
1 2 3 4 5


Output

5
1 2 3 4 5 

Input

5
1 3 5 6 8


Output

2
3 5 

Input

3
1 5 3


Output

1
3 

Note

In the first example, any k is suitable, since a is an arithmetic progression.

Possible arrays x:

  * [1]
  * [1, 1]
  * [1, 1, 1]
  * [1, 1, 1, 1] 
  * [1, 1, 1, 1, 1]



In the second example, Bajtek's array can have three or five elements.

Possible arrays x:

  * [1, 2, 2]
  * [1, 2, 2, 1, 2]



For example, k = 4 is bad, since it leads to 6 + x_0 = 8 and 0 + x_0 = 1, which is an obvious contradiction.

In the third example, only k = n is good.

Array [1, 4, -2] satisfies the requirements.

Note that x_i may be negative.
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

/* public class Solution {
    public static void main(String args[] ) throws Exception {
        // Enter your code here. Read input from STDIN. Print output to STDOUT 
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        pw.println("test");
        pw.close();
    }
} */

public class LostArray {
    
    static StringTokenizer st;
    static BufferedReader sc;
    static PrintWriter pw;
    
    public static void main(String args[]) throws Exception {
        sc = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
            System.out)));
        int n = nextInt();
        long [] a = new long[n+1];
        int sum = 0;
        int max = 0;
        int r=0;
        boolean [] possible = new boolean [n+1];
        int count=1;
        possible[n]=true;
        for (int i=1;i<=n;i++) {
        	a[i]=  nextLong();
        }
        //for (int i=1;i<=n;i++) {
        	for (int k=1; k<=n-1; k++) {
        		long [] tmp = new long[k+1];
        		tmp[1]=a[1];
        		for (int x=2;x<=k;x++) {
        			tmp[x]=a[x]-a[x-1];
        		}
        		boolean  p = true;
        		for (int x=k+1;x<=n;x++) {
        			int ind = (x-k)%k== 0 ? k : (x-k)%k;
        			if (a[x]-a[x-1]!= tmp[ind]) {
        				p=false;
        				break;
        			}
        		}
        		if (p) {
        			count++;
        			possible[k]=true;
        		}
        		
        	}
        //}
        pw.println(count);
        for (int i=1;i<=n;i++) {
        	if (possible[i])
        	pw.print(i+" ");
        }
        
        pw.close();
        
    }
    
    public static boolean istPalindrom(char[] word){
        int i1 = 0;
        int i2 = word.length - 1;
        while (i2 > i1) {
            if (word[i1] != word[i2]) {
                return false;
            }
            ++i1;
            --i2;
        }
        return true;
    }
    
    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

/*  private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
*/
    private static String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(sc.readLine());
        return st.nextToken();
    }


}
