It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k ≥ 0, 0 < r ≤ 2k. Let's call that representation prairie partition of x.

For example, the prairie partitions of 12, 17, 7 and 1 are: 

12 = 1 + 2 + 4 + 5,

17 = 1 + 2 + 4 + 8 + 2,

7 = 1 + 2 + 4,

1 = 1. 

Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!

Input

The first line contains a single integer n (1 ≤ n ≤ 105) — the number of numbers given from Alice to Borys.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012; a1 ≤ a2 ≤ ... ≤ an) — the numbers given from Alice to Borys.

Output

Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.

If there are no such values of m, output a single integer -1.

Examples

Input

8
1 1 2 2 3 4 5 8


Output

2 


Input

6
1 1 1 2 2 2


Output

2 3 


Input

5
1 2 4 4 4


Output

-1

Note

In the first example, Alice could get the input sequence from [6, 20] as the original sequence.

In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3].
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class A {

	static long solve(long x, long y, long q){
		long p = 1;
		long l = 1;
		long h = (long) 1e8;
		long ans = -1;
		while(l <= h) {
			long mid = (l + h) / 2;
			if(1l * p * mid - x <= 1l * q * mid - y && 1l * p * mid >= x) {
				ans = mid;
				h = mid - 1;
			}else
				l = mid + 1;
		}
		return(ans == -1 ? ans : ans * q - y);

	}


	public static void main(String[] args) throws Exception{
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int n = sc.nextInt();

		int[] occ = new int[50];
		ArrayList<Long> barra = new ArrayList<>(); 
		int total = 0;
		for (int i = 0; i < n; i++) {
			long x = sc.nextLong();

			int a = 0;

			while(1l << a <= x) {
				if(1l << a == x) {
					occ[a]++;
					total++;
					break;
				} else 
					a++;
			}
			
			if(1l << a > x)
				barra.add(x);
		}
		if(occ[0] == 0 || n - total > occ[0])
		{
			System.out.println(-1);
			return;
		}
		
		int[] arr = new int[occ[0]];
		Arrays.fill(arr, 1);
		
		int end = occ[0];
		for (int i = 1; i < occ.length; i++) {
			for (int j = end; j < occ[i]; j++)
				barra.add((1l << i));
			end = Math.min(occ[i], end);
			for (int j = 0; j < end; j++) {
				arr[j]++;
			}	

		}
		if(barra.size() > occ[0])
		{
			System.out.println(-1);
			return;
		}
		Collections.sort(barra);
		for (int i = barra.size() - 1, j = 0; i >= 0; i--, j++) {
			if(barra.get(i) >= (1l << arr[j])) {
				System.out.println(-1);
				return;
			}
		}
		int l = arr.length;
		int r = l;
		int start = barra.size();
		for (int i = arr.length - 1; i >= 0; i--) {
			if(start + arr[i] > i)
				break;

			start += arr[i];
			l = i;
		}

		for (int i = l; i <= r; i++)
			out.print(i + " ");
		out.println();
		out.flush();
		out.close();
	}

	static class Scanner 
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream System){	br = new BufferedReader(new InputStreamReader(System));}
		public String next() throws IOException 
		{
			while (st == null || !st.hasMoreTokens()) 
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public String nextLine()throws IOException{return br.readLine();}
		public int nextInt() throws IOException {return Integer.parseInt(next());}
		public double nextDouble() throws IOException {return Double.parseDouble(next());}
		public char nextChar()throws IOException{return next().charAt(0);}
		public Long nextLong()throws IOException{return Long.parseLong(next());}
		public boolean ready() throws IOException{return br.ready();}
		public void waitForInput(){for(long i = 0; i < 3e9; i++);}
	}
}