#include <cstdio>
#include <cstdlib>
#include <cctype>

struct AVL {
  int key;
  int height;
  int freq;
  struct AVL *left, *right;
} *NIL;

typedef struct AVL AVL;

//int buffer;
//AVL** memoryBuffer;

const int MAX_READER = 4096 * 16;
int pos;
char reader[MAX_READER];

inline char getChar(FILE* f) {
  if (pos == MAX_READER) {
    pos = 0;
    fread(reader, MAX_READER, 1, f);
  }
  return reader[pos++];
}

inline int read(FILE* f) {
  char c;
  do {
    c = getChar(f);
  } while (!isdigit(c));
  int ret = 0;
  do {
    ret = (ret << 3) + (ret << 1) + c - '0';
    c = getChar(f);
  } while (isdigit(c));
  return ret;
}

AVL* init() {
  NIL = (AVL*)malloc(sizeof(AVL));
  NIL -> key = 0;
  NIL -> height = 0;
  NIL -> freq = 0;
  NIL -> left = NIL -> right = NULL;
  return NIL;
}

int MAX(int X, int Y) {
  return X > Y ? X : Y;
}

void calculateHeight(AVL* tree) {
  tree -> height = 1 + MAX(tree -> left -> height, tree -> right -> height);
}

AVL* rotateRight(AVL* tree) {
  AVL* save = tree -> right;
  tree -> right = tree -> right -> left;
  save -> left = tree;
  calculateHeight(tree);
  calculateHeight(save);
  return save;
}

AVL* rotateLeft(AVL* tree) {
  AVL* save = tree -> left;
  tree -> left = tree -> left -> right;
  save -> right = tree;
  calculateHeight(tree);
  calculateHeight(save);
  return save;
}

AVL* balance(AVL* tree) {
  calculateHeight(tree);

  // Need right rotation.
  if ((tree -> right -> height - tree -> left -> height) > 1) {
    if (tree -> right -> left -> height >
        tree -> right -> right -> height)
      tree -> right = rotateLeft(tree -> right);
    tree = rotateRight(tree);
  } else if ((tree -> left -> height - tree -> right -> height) > 1) {
    if (tree -> left -> right -> height >
        tree -> left -> left -> height)
      tree -> left = rotateRight(tree -> left);
    tree = rotateLeft(tree);
  }
  return tree;
}

/*
bool find(AVL* tree, const int key) {
  if (tree == NIL)
    return false;
  if (tree -> key == key)
    return true;
  if (key < tree -> key)
    return find(tree -> left, key);
  return find(tree -> right, key);
}

AVL* allocMemory() {
  if (stackSize) {
    return stack[--stackSize];
  }
  if (buffer == MAX_BUFF) {
    buffer = 0;
    memoryBuffer = (AVL**)calloc(MAX_BUFF, sizeof(AVL*));
    for (int i = 0; i < MAX_BUFF; i++) {
      memoryBuffer[i] = (AVL*)malloc(sizeof(AVL));
    }
  }
  return memoryBuffer[buffer++];
}
*/
AVL* insert(AVL* tree, const int key) {
  if (tree == NIL) {
    //memoryBuffer[buffer] = (AVL*)malloc(sizeof(AVL));
    //tree = memoryBuffer[buffer++];
    tree = (AVL*)malloc(sizeof(AVL));

    //fprintf(stderr, "%x\n", *tree);
    tree -> key = key;
    tree -> height = 1;
    tree -> freq = 1;
    tree -> left = tree -> right = NIL;
    //fprintf(stderr, "raus");
    return tree;
  }
  if (tree -> key == key) {
    tree -> freq++;
    return tree;
  }
  if (key < tree -> key)
    tree -> left = insert(tree -> left, key);
  else
    tree -> right = insert(tree -> right, key);
  return balance(tree);
}

/*
AVL* erase(AVL* tree, const int key) {
  if (tree == NIL)
    return tree;
  if (tree -> key == key) {
    if ((tree -> left == NIL) || (tree -> right == NIL)) {
      AVL* ret = (tree -> left == NIL) ? tree -> right : tree -> left;
      push(tree);
      return ret;
    } else {
      // Both aren't NIL.
      AVL* next;
      for (next = tree -> right; next -> left != NIL; next = next -> left);
      tree -> key = next -> key;
      tree -> right = erase(tree -> right, next -> key);
      return balance(tree);
    }
  } else if (key < tree -> key) {
    tree -> left = erase(tree -> left, key);
  } else {
    tree -> right = erase(tree -> right, key);
  }
  return balance(tree);
}
*/

void print(FILE* out, AVL* tree) {
  if (tree == NIL)
    return;
  print(out, tree -> left);
  while (tree -> freq--)
    fprintf(stdout, "%d ", tree -> key);
  print(out, tree -> right);
}

int main(void) {
  FILE *f = fopen("algsort.in", "r");
  freopen("algsort.out", "w", stdout);

  AVL* root = init();

  int N = read(f);
  //buffer = 0;
  //memoryBuffer = (AVL**)calloc(N, sizeof(AVL*));
  for (int i = 0; i < N; i++) {
    root = insert(root, read(f));
  }
  print(stdout, root);
  return 0;
}