"""# 

### 谜题描述
You are given a set Y of n distinct positive integers y1, y2, ..., yn.

Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:

  1. Take any integer xi and multiply it by two, i.e. replace xi with 2·xi. 
  2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2·xi + 1. 



Note that integers in X are not required to be distinct after each operation.

Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.

Note, that any set of integers (or its permutation) generates itself.

You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 50 000) — the number of elements in Y.

The second line contains n integers y1, ..., yn (1 ≤ yi ≤ 109), that are guaranteed to be distinct.

Output

Print n integers — set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.

Examples

Input

5
1 2 3 4 5


Output

4 5 2 3 1 


Input

6
15 14 3 13 1 12


Output

12 13 14 7 3 1 


Input

6
9 7 13 17 5 11


Output

4 5 2 6 3 1 

Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
```python
import sys, math
from sys import stdin, stdout
from collections import deque
from copy import deepcopy
from bisect import bisect_right
from heapq import heapify,heappop,heappush,heapreplace
rem = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 6)
take = lambda: map(int, stdin.readline().split())

n=input()
pin=take()
arr=[]
for i in pin:
    arr.append(-i)

heapify(arr)
done={}
for i in arr:
    done[-i]=1
while(len(arr)):
    x=-heappop(arr)
    y=x/2
    yes=False
    while(y>0):
        if done.get(y,-1)==-1:
            done[y]=1
            yes=True
            break
        y/=2
    #print y,x
    if yes==True:
        del done[x]
        heappush(arr,-y)



for i in done:
    print i,
```


请完成上述谜题的训练场环境类实现，包括所有必要的方法。
"""

from bootcamp import Basebootcamp
import random
from bootcamp import Basebootcamp

class Dgeneratingsetsbootcamp(Basebootcamp):
    def __init__(self, **params):
        super().__init__()
        self.n = params.get('n', 5)
        self.max_number = params.get('max_number', 100)
    
    def case_generator(self):
        n = self.n
        max_num = self.max_number
        while True:
            X = random.sample(range(1, max_num + 1), n)
            Y = []
            for x in X:
                current = x
                k = random.randint(0, 10)
                for _ in range(k):
                    op = random.choice([0, 1])
                    if op == 0:
                        current = current * 2
                    else:
                        current = current * 2 + 1
                Y.append(current)
            Y = list(set(Y))
            if len(Y) >= n:
                Y = Y[:n]
                break
        Y.sort()
        return {'y': Y}
    
    @staticmethod
    def prompt_func(question_case):
        Y = question_case['y']
        y_str = ' '.join(map(str, Y))
        prompt = f"你是一个数学专家，现在需要解决一个数学谜题。给定一个集合Y={{ {y_str} }}，请找出一个集合X，使得X可以通过一系列操作生成Y。操作包括：将X中的元素乘以2，或者乘以2加1。X中的元素必须互不相同，并且X的最大元素尽可能小。请将X的元素以空格分隔的形式放在[answer]标签中，例如：[answer]4 5 2 3 1[/answer]"
        return prompt
    
    @staticmethod
    def extract_output(output):
        start = output.rfind('[answer]')
        if start == -1:
            return None
        end = output.find('[/answer]', start)
        if end == -1:
            return None
        content = output[start + len('[answer]'):end].strip()
        if not content:
            return None
        try:
            X = list(map(int, content.split()))
            return X
        except ValueError:
            return None
    
    @classmethod
    def _verify_correction(cls, solution, identity):
        Y = identity['y']
        X = solution
        if len(X) != len(Y):
            return False
        if len(set(X)) != len(X):
            return False
        for y in Y:
            current = y
            found = False
            while current > 0:
                if current in X:
                    found = True
                    break
                if current % 2 == 0:
                    current = current // 2
                else:
                    current = (current - 1) // 2
            if not found:
                return False
        return True