A student of z-school found a kind of sorting called z-sort. The array a with n elements are z-sorted if two conditions hold:

  1. ai ≥ ai - 1 for all even i, 
  2. ai ≤ ai - 1 for all odd i > 1. 



For example the arrays [1,2,1,2] and [1,1,1,1] are z-sorted while the array [1,2,3,4] isn’t z-sorted.

Can you make the array z-sorted?

Input

The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array a.

The second line contains n integers ai (1 ≤ ai ≤ 109) — the elements of the array a.

Output

If it's possible to make the array a z-sorted print n space separated integers ai — the elements after z-sort. Otherwise print the only word "Impossible".

Examples

Input

4
1 2 2 1


Output

1 2 1 2


Input

5
1 3 2 2 5


Output

1 5 2 3 2
import java.io.BufferedReader;
import java.io.FileReader;
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.StringTokenizer;

public class Main {
        static ArrayList<Integer>[] arr;
        static boolean[] removed;
        static int x;
        static int ans;
        static boolean[] vis;
        static boolean check;

    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        //==================================================//
        //answer here:
        int n=scanner.nextInt();
        Integer[] arr=new Integer[n];
        for (int i=0; i<n; i++){
            arr[i]=scanner.nextInt();
        }
        Arrays.sort(arr);
        int i=0;
        int j=n-1;
        int c=0;
        int[] ans=new int[n];
        while(i<=j){
            ans[c++]=arr[i++];
            if (i>j) break;
            ans[c++]=arr[j--];
        }
        for (int loop=0; loop<n; loop++){
            out.print(ans[loop]+" ");
        }

        //==================================================//
        out.close();
    }
}
class pair implements Comparable<pair>{
    public int value;
    public int index;
    public pair(int v,int i){
        this.value=v;
        this.index=i;
    }
    @Override
    public int compareTo(pair o){
      if ((index & 1)==0) //ascending for even
          return value -o.value;
      else
          return o.value- value;
    }
    public String toString(){
        return ""+this.value;
    }

}

class Scanner{
    StringTokenizer st;
    BufferedReader br;

    public Scanner(InputStream system) {br = new BufferedReader(new InputStreamReader(system));}
    public Scanner(String file) throws Exception {br = new BufferedReader(new FileReader(file));}
    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() throws InterruptedException {Thread.sleep(3000);}
    int[] readArray(int n) throws  IOException{
        int[] a=new int[n];
        for (int i=0; i<n; i++)
            a[i]=nextInt();
        return a;
    }
    long[] readLongArray(int n) throws IOException {
        long[] a=new long[n];
        for (int i=0; i<n; i++)
            a[i]=nextLong();
        return a;
    }
}

