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

struct AVL {
  int key;
  int code;
  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 -> code = 0;
  NIL -> left = NIL -> right = NULL;
  return NIL;
}

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

const int MASK = (1 << 20) - 1;
#define height code & MASK
#define freq code >> 20

int encode(int f, int h) {
  return (f << 20) | h;
}

void calculateHeight(AVL* tree) {
  tree -> code = encode(tree -> code >> 20, 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 -> code = encode(1, 1);
    tree -> left = tree -> right = NIL;
    //fprintf(stderr, "raus");
    return tree;
  }
  if (tree -> key == key) {
    tree -> code = encode((tree -> freq) + 1, tree -> height);
    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(std::ofstream& file, AVL* tree) {
  if (tree == NIL)
    return;
  print(file, tree -> left);
  int f = tree -> freq;
  while (f--)
    file << tree -> key << " ";
  print(file, tree -> right);
}

int main(void) {
  //FILE *f = fopen("algsort.in", "r");
  //freopen("algsort.out", "w", stdout);
  std::ifstream cin("algsort.in");
  std::ofstream cout("algsort.out");


  AVL* root = init();

  int N;
  cin >> N;
  //buffer = 0;
  //memoryBuffer = (AVL**)calloc(N, sizeof(AVL*));
  for (int i = 0; i < N; i++) {
    int x;
    cin >> x;
    root = insert(root, x);
  }
  print(cout, root);
  return 0;
}