We're giving away nice huge bags containing number tiles! A bag we want to present to you contains n tiles. Each of them has a single number written on it — either 1 or 2.

However, there is one condition you must fulfill in order to receive the prize. You will need to put all the tiles from the bag in a sequence, in any order you wish. We will then compute the sums of all prefixes in the sequence, and then count how many of these sums are prime numbers. If you want to keep the prize, you will need to maximize the number of primes you get.

Can you win the prize? Hurry up, the bags are waiting!

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of number tiles in the bag. The following line contains n space-separated integers a_1, a_2, ..., a_n (a_i ∈ \{1, 2\}) — the values written on the tiles.

Output

Output a permutation b_1, b_2, ..., b_n of the input sequence (a_1, a_2, ..., a_n) maximizing the number of the prefix sums being prime numbers. If there are multiple optimal permutations, output any.

Examples

Input


5
1 2 1 2 1


Output


1 1 1 2 2


Input


9
1 1 2 1 1 1 2 1 1


Output


1 1 1 2 1 1 1 2 1

Note

The first solution produces the prefix sums 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, \mathbf{\color{blue}{7}} (four primes constructed), while the prefix sums in the second solution are 1, \mathbf{\color{blue}{2}}, \mathbf{\color{blue}{3}}, \mathbf{\color{blue}{5}}, 6, \mathbf{\color{blue}{7}}, 8, 10, \mathbf{\color{blue}{11}} (five primes). Primes are marked bold and blue. In each of these cases, the number of produced primes is maximum possible.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;


public class MAxPrime {

	static class FastReader { 
		BufferedReader br; 
		StringTokenizer st; 

		public FastReader() 
		{ 
			br = new BufferedReader(new
					InputStreamReader(System.in)); 
		} 

		String next() 
		{ 
			while (st == null || !st.hasMoreElements()) 
			{ 
				try
				{ 
					st = new StringTokenizer(br.readLine()); 
				} 
				catch (IOException  e) 
				{ 
					e.printStackTrace(); 
				} 
			} 
			return st.nextToken(); 
		} 

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

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

		double nextDouble() 
		{ 
			return Double.parseDouble(next()); 
		} 

		String nextLine() 
		{ 
			String str = ""; 
			try
			{ 
				str = br.readLine(); 
			} 
			catch (IOException e) 
			{ 
				e.printStackTrace(); 
			} 
			return str; 
		} 
	}

	// Java program to print all primes smaller than or equal to 
	// n using Sieve of Eratosthenes 

	static ArrayList<Integer> sieve(int n) 
	{ 
		// Create a boolean array "prime[0..n]" and initialize 
		// all entries it as true. A value in prime[i] will 
		// finally be false if i is Not a prime, else true. 
		boolean prime[] = new boolean[n+1]; 
		for(int i=0;i<n;i++) 
			prime[i] = true; 

		for(int p = 2; p*p <=n; p++) 
		{ 
			// If prime[p] is not changed, then it is a prime 
			if(prime[p] == true) 
			{ 
				// Update all multiples of p 
				for(int i = p*2; i <= n; i += p) 
					prime[i] = false; 
			} 
		} 

		// Print all prime numbers 
		ArrayList<Integer> al = new ArrayList();
		for(int i = 2; i <= n; i++) 
		{ 
			if(prime[i] == true) 
				al.add(i);
		} 
		return al;
	} 

	static int get(int a, ArrayList<Integer> al ,int n) {
		int i1 = 0;
		int l = 0;
		int r = n-1;
		int mid;
		while(l!=r){
			mid = (l+r)/2;
			if(al.get(mid)>=a) {
				r=mid;
			} else {
				l=mid+1;
			}
		}
		i1 = l;
		return al.get(i1);
	}

	public static void main(String[] args) {

		FastReader sc = new FastReader();
		OutputStream outputstream = System.out;
		PrintWriter out = new PrintWriter(outputstream);

		int n = sc.nextInt();
		int[] arr = new int[n];
		int ones = 0;
		int twos = 0;
		ArrayList<Integer> al = sieve(401000);
		for(int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
			if(arr[i]== 1) ones++;
			else twos++;
		}
		
		int sum = 0;
		int next = 2;
		int tt;
		int to;
		int ind = 0;
		while(ones>0||twos>0) {
			tt = (next-sum)/2;
			if(tt>twos) tt= twos;
			to = ((next-sum)-tt*2);
			if(to>ones) to = ones;
			ones -= to;
			twos -= tt;
			for(int i = 0; i < tt; i++) {
				sum += 2;;
				out.print(2 + " ");
			}
			for(int i = 0; i < to; i++) {
				sum++;
				out.print(1 + " ");
			}
			ind++;
			next = al.get(ind);
			//next = get(sum+1,al,al.size());
		}
		//out.println(get(10,al,al.size()));
		//for(Integer i : al) out.println(i);
		out.close();
	}

}