class ArraySort {

    private static int cnt = 0;

    static boolean less (double x, double y) {
	cnt++; return x < y;
    }

    static void exch (double a[], int i, int j) {
	double t = a[i]; a[i] = a[j]; a[j] = t;
    }

    static void compExch (double a[], int i, int j) {
	if (less (a[j], a[i])) exch (a, i, j);
    }

    public static void bubble_sort (double a[], int l, int r) {
	for (int i = l; i < r; i++)
	    for (int j = r; j > i; j--)
		compExch (a, i, j);
    }

    static int minimum (double a[], int l, int r) {
	int min = l;

	for (int i = l+1; i <= r; i++) {
	    if (less (a[i], a[min])) min = i;
	}

	return min;
    }

    public static void selection_sort_1
	(double a[], int l, int r) {
	int min;
	for (int i = l; i <= r; i++) {
	    min = minimum (a, i, r);
	    exch (a, i, min);
	}
    }

    public static void selection_sort_2
	(double a[], int l, int r) {
	int min;
	for (int i = l; i <= r; i++) {
	    min = i;
	    for (int j = i+1; j <= r; j++) {
		if (less (a[j], a[min])) min = j;
	    }
	    exch (a, i, min);
	}
    }

    public static void insertion_sort
	(double a[], int l, int r) {
	int i;
	for (i = r; i > l; i--) compExch (a, i-1, i);
	for (i = l+2; i <= r; i++) {
	    int j = i;
	    double t = a[i];
	    while (t < a[j-1]) {
		a[j] = a[j-1];
		j = j -1;
	    }
	    a[j] = t;
	}
    }

    static int partition // we require l < r
	(double a[], int l, int r) {
	int i = l, j = r-1;
	double p = a[r];

	for (;;) {
	    while (less (a[i], p)) i = i + 1;
	    while (less (p, a[j])) {
		j = j - 1;
		if (j < l) break;
	    }
	    if (i >= j) break;
	    exch (a, i, j);
	    i = i + 1;
	    j = j - 1;
	}

	exch (a, i, r);
	return i;
    }

    static void quick_sort
	(double a[], int l, int r) {

	if (r <= l) return;
	int i = partition (a, l, r);
	quick_sort (a, l, i-1);
	quick_sort (a, i+1, r);
    }
    
    // precondition: a is bitonic
    // postcondition: b is montonic
    static void merge (double a[], double b[], int l, int r) {
	int i, j, k;

	i = l; j = r; k = l; // initialization

	while (i <= j) {
	    if (a[i] < a[j]) {
		b[k++] = a[i++];
	    } else {
		b[k++] = a[j--];
	    }
	}
    }

    // this is top-down merge_sort
    static void merge_sort (double a[], int l, int r) {
	double a_copy[] = new double [a.length];

	if (r <= l+1) { compExch (a, l, r); return; }

	int m = (r+l)/2;

	merge_sort (a, l, m);
	merge_sort (a, m+1, r);

	for (int i = l; i <= m; i++) a_copy[i] = a[i];
	for (int i = m+1; i <= r; i++) a_copy[r+m+1-i] = a[i];

	merge (a_copy, a, l, r);
    }

    public static void main (String args[]) {
	int N = Integer.parseInt(args[0]);
	double a[] = new double [N];
	for (int i = 0; i < N; i++) {
	    a[i] = Math.random();
	}

	/*
	quick_sort (a, 0, N-1);
	*/
	merge_sort (a, 0, N-1);

	if (N < 100) {
	    for (int i = 0; i < N; i++) {
		Out.println (a[i] + "");
	    }
	}

	Out.println ("Compares used: " + cnt);
    }

}