// Author: Manolea Teodor-Stefan
#include <bits/stdc++.h>
//#pragma GCC optimize("O3,unroll-loops")
//#pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt")

//#define fin cin
//#define fout cout

namespace ano {
    // typenames
    template<typename T>
    using  _iterator = typename std::vector<T>::iterator;
    template<typename T>
    using _queue = typename std::queue<T>;

    // functions
    template<typename T>
    /**
     * Merge
     *
     * @brief collates the vector
     * @tparam T
     * @param begin and end iterators of a vector
     */
    void Merge(_iterator<T> __begin, _iterator<T> __end) {
        _queue<T> __q;
        const size_t __dist = (__end - __begin) / 2;
        _iterator<T> __mid = __begin + __dist;
        _iterator<T> __i = __begin;
        _iterator<T> __j = __mid;

        while (__i < __mid || __j < __end) {
            if (__i < __mid && __j < __end) {
                if (*__i < *__j) {
                    __q.push(*__i);
                    __i++;
                } else {
                    __q.push(*__j);
                    __j++;
                }
            } else {
                if (__i < __mid) {
                    __q.push(*__i);
                    __i++;
                } else if (__j < __end) {
                    __q.push(*__j);
                    __j++;
                }
            }
        }
        while (!__q.empty()) {
            *__begin = __q.front();
            __q.pop();
            __begin++;
        }
    }

    template<typename T>
    /**
     * Merge sort
     *
     * @brief sorts the vector using merge sort
     * @tparam T
     * @param begin and end iterators of a vector
     */
    void MergeSort(_iterator<T> __begin, _iterator<T> __end) {
        const size_t __dist = __end - __begin;
        _iterator<T> __mid = __begin + __dist / 2;

        if (__dist > 1) {
            MergeSort<T>(__begin,__mid);
            MergeSort<T>(__mid,__end);
            Merge<T>(__begin,__end);
        }
    }


    template<typename T>
    /**
     * GetBiggest
     *
     * @brief gets the biggest element out of two iterators
     * @tparam T
     * @param begin and end iterators of a vector
     * @return pivot iterator
     */
     _iterator<T> GetBiggest(_iterator<T> A, _iterator<T> B) {
         if (*A < *B) {
             return B;
         }
        return A;
     }

    template<typename T>
    /**
     * Median
     *
     * @brief gets the median of three parts of an range
     * @tparam T
     * @param A and B iterator
     * @return median for pivot
     */
    _iterator<T> Median(_iterator<T> __begin, _iterator<T> __end) {
        _iterator<T> __mid = __begin + (__end - __begin) / 2;

        _iterator<T> __biggest = GetBiggest<T>(__begin,GetBiggest<T>(__mid,__end));

        if (__biggest == __begin) {
            return GetBiggest<T>(__mid,__end);
        }
        if (__biggest == __end) {
            return GetBiggest<T>(__begin,__mid);
        }

        return GetBiggest<T>(__begin,__end);
    }


    template<typename T>
    /**
     * Partition
     *
     * @brief sorts by pivot
     * @tparam T
     * @param begin and end iterators of a vector
     * @return pivot iterator
     */
    _iterator<T> Partition(_iterator<T> __begin, _iterator<T> __end) {
        _iterator<T> __pivot = Median<T>(__begin,__end - 1);
        _iterator<T> __ret = __begin;
        std::swap(*__pivot,*__end);
        for (; __begin != __end; __begin++) {
            if (*__begin > *__end) {
                std::swap(*__begin,*__end);
                __ret++;
            }
        }
        return __pivot;
    }

    template<typename T>
    /**
     * Quick sort
     *
     * @brief sorts the vector using quick sort
     * @tparam T
     * @param begin and end iterators of a vector
     */
    void QuickSort(_iterator<T> __begin, _iterator<T> __end) {
        const size_t __dist = __end - __begin;
        if (__dist > 1) {
            _iterator<T> __pivot = Partition<T>(__begin,__end);
            QuickSort<T>(__begin, __pivot);
            QuickSort<T>(__pivot + 1, __end);
        }
    }
}
using namespace std;
ifstream fin("algsort.in");
ofstream fout("algsort.out");

int n;
vector<int> v;
int main() {
    fin >> n;
    v.resize(n);
    for (int& i : v) {
        fin >> i;
    }

    random_shuffle(v.begin(),v.end());
    swap(v.front(),v.back());
    ano::QuickSort<int>(v.begin(),v.end());
    for (const int i : v) {
        fout << i << ' ';
    }
    return 0;
}