import static java.util.Arrays.copyOf;
import static java.util.Arrays.copyOfRange;
import static java.util.Objects.requireNonNull;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.StringTokenizer;

public final class Main {
  public static final String IN_FILE = "algsort.in";
  public static final String OUT_FILE = "algsort.out";

  public static final class FastScanner implements AutoCloseable {
    private final BufferedReader reader;
    private StringTokenizer tokenizer;

    public FastScanner(final String fileName) throws IOException {
      reader = new BufferedReader(
          new InputStreamReader(new FileInputStream(fileName)));
    }

    private String next() throws IOException {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        final String line = requireNonNull(reader.readLine());
        tokenizer = new StringTokenizer(line);
      }
      return tokenizer.nextToken();
    }

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

    @Override
    public void close() throws IOException {
      reader.close();
    }
  }

  private static int[] merge(final int[] left, final int[] right) {
    final int m = left.length;
    final int n = right.length;
    final int[] result = new int[m + n];
    int i = 0;
    int j = 0;
    int k = 0;
    while (i < m || j < n) {
      if (i < m && (j == n || left[i] <= right[j])) {
        result[k++] = left[i++];
      } else {
        result[k++] = right[j++];
      }
    }
    return result;
  }

  public static int[] mergeSort(final int[] values) {
    if (values.length <= 1) {
      return copyOf(values, values.length);
    }
    final int middle = values.length / 2;
    final int[] left = mergeSort(copyOfRange(values, 0, middle));
    final int[] right = mergeSort(copyOfRange(values, middle, values.length));
    return merge(left, right);
  }

  public static void mergeSort(
      final int[] values, final int left, final int right, final int[] aux) {
    final int middle = left + (right - left) / 2;

  }

  public static int[] readValues(final FastScanner scanner) throws IOException {
    final int n = scanner.nextInt();
    final int[] values = new int[n];
    for (int i = 0; i < n; i++) {
      values[i] = scanner.nextInt();
    }
    return values;
  }

  public static void writeValues(final PrintWriter writer, final int[] values) {
    for (int i = 0; i < values.length; i++) {
      writer.print(values[i]);
      writer.print(i + 1 < values.length ? ' ' : '\n');
    }
  }

  public static void main(final String[] args) throws IOException {
    try (final FastScanner scanner = new FastScanner(IN_FILE);
        final PrintWriter writer = new PrintWriter(OUT_FILE)) {
      final int[] values = readValues(scanner);
      final int[] sorted = mergeSort(values);
      writeValues(writer, sorted);
    }
  }
}