Polycarp likes to play with numbers. He takes some integer number xx, writes it down on the board, and then performs with it n−1n−1 operations of the two kinds:

  • divide the number xx by 33 (xx must be divisible by 33);
  • multiply the number xx by 22.

After each operation, Polycarp writes down the result on the board and replaces xx by the result. So there will be nn numbers on the board after all.

You are given a sequence of length nn — the numbers that Polycarp wrote down. This sequence is given in arbitrary order, i.e. the order of the sequence can mismatch the order of the numbers written on the board.

Your problem is to rearrange (reorder) elements of this sequence in such a way that it can match possible Polycarp's game in the order of the numbers written on the board. I.e. each next number will be exactly two times of the previous number or exactly one third of previous number.

It is guaranteed that the answer exists.

Input

The first line of the input contatins an integer number nn (2≤n≤1002≤n≤100) — the number of the elements in the sequence. The second line of the input contains nninteger numbers a1,a2,…,ana1,a2,…,an (1≤ai≤3⋅10181≤ai≤3⋅1018) — rearranged (reordered) sequence that Polycarp can wrote down on the board.

Output

Print nn integer numbers — rearranged (reordered) input sequence that can be the sequence that Polycarp could write down on the board.

It is guaranteed that the answer exists.

Examples

Input 
6
4 8 6 3 12 9
Output 
9 3 6 12 4 8
Input 
4
42 28 84 126
Output 
126 42 84 28
Input 
2
1000000000000000000 3000000000000000000
Output 
3000000000000000000 1000000000000000000

Note

In the first example the given sequence can be rearranged in the following way: [9,3,6,12,4,8][9,3,6,12,4,8]. It can match possible Polycarp's game which started with x=9x=9.

 

题意：

给你一个含有N个数的数组，让你重新定义他们的顺序，使之a[i] 和a[i-1] 只有两种关系

1. a[i]=a[i-1]/3

2. a[i]=a[ i-1 ] * 2

 

思路：

暴力DFS竟然骗过，难以置信。

正解的思路是：

我们定义一个数x的cnt3是它唯一分解后3的次幂数。

因为只有/3的操作，所以整个数组中cnt3一定是单调不递增的，

而相同的cnt3中的数，关系一定是*2的关系，那么一定是单调递增的排序。

那么我们只需要把数都压入到一个pair中，first 是这个数的cnt3，second是这个数，然后进行默认的pair排序。

默认的pair排序是，先以first递增排序，相同的first的以second递增排序。

那么我们把每一个数的cnt3取为负值，即-cnt3。

那么就直接排序就输出结果了。

细节见代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int count3(LL x){
  int ret=0;
  while(x % 3 == 0){
    ret++;
    x /= 3;
  }
  return ret;
}
int n;
vector<pair<int,LL>> v;
int main(){
  cin>>n;
  v.resize(n);
  for(int i=0; i<n; i++){
    cin>>v[i].second;
    v[i].first=-count3(v[i].second);
  }
  sort(v.begin(), v.end());
  for(int i=0;i<n;i++)
  {
      printf("%d %lld\n",v[i].first, v[i].second);
  }
  for(int i=0; i<n; i++)
    printf("%lld%c", v[i].second, " \n"[i + 1 == n]);
}