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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskE {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            long[] a = new long[N];

            long[] cntMatch = new long[50];
            long[] cntNotMatch = new long[50];
            for (int i = 0; i < N; i += 1) {
                a[i] = in.nextLong();
                for (int p = 0; p < cntMatch.length; p += 1) {
                    if ((1L << p) == a[i]) {
                        cntMatch[p] += 1;
                        break;
                    } else if ((1L << p) > a[i]) {
                        cntNotMatch[p - 1] += 1;
                        break;
                    }
                }
            }
            for (int i = 0; i < cntMatch.length - 1; i += 1) {
                if (cntMatch[i] < cntMatch[i + 1]) {
                    cntNotMatch[i + 1] += cntMatch[i + 1] - cntMatch[i];
                    cntMatch[i + 1] = cntMatch[i];
                }
            }
            long maxM = cntMatch[0];
            for (int i = cntMatch.length - 1; i >= 0; i -= 1) {
                if (cntMatch[i] > 0) {
                    for (int j = i - 1; j >= 0; j -= 1) {
                        cntMatch[j] -= cntMatch[i];
                    }
                }
            }
            long margin = 0;
            long consume = 0;
            for (int i = cntMatch.length - 1; i >= 0; i -= 1) {
                margin += cntMatch[i];
                margin -= cntNotMatch[i];
                if (margin < 0) {
                    out.println(-1);
                    return;
                }
                consume += cntNotMatch[i];
            }
            ArrayList<Long> ans = new ArrayList<>();
            ans.add(maxM);
            int idx = 0;
            while (true) {
                while (cntMatch[idx] == 0) idx += 1;
                cntMatch[idx] -= 1;
                maxM -= 1;
                consume += idx + 1;
                if (consume > maxM) break;
                ans.add(maxM);
            }
            for (int i = ans.size() - 1; i >= 0; i -= 1) {
                if (i < ans.size() - 1) out.print(" ");
                out.print(ans.get(i));
            }
            out.println();
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}

