Ivan has an array consisting of n different integers. He decided to reorder all elements in increasing order. Ivan loves merge sort so he decided to represent his array with one or several increasing sequences which he then plans to merge into one sorted array.

Ivan represent his array with increasing sequences with help of the following algorithm.

While there is at least one unused number in array Ivan repeats the following procedure:

  * iterate through array from the left to the right; 
  * Ivan only looks at unused numbers on current iteration; 
  * if current number is the first unused number on this iteration or this number is greater than previous unused number on current iteration, then Ivan marks the number as used and writes it down. 



For example, if Ivan's array looks like [1, 3, 2, 5, 4] then he will perform two iterations. On first iteration Ivan will use and write numbers [1, 3, 5], and on second one — [2, 4].

Write a program which helps Ivan and finds representation of the given array with one or several increasing sequences in accordance with algorithm described above.

Input

The first line contains a single integer n (1 ≤ n ≤ 2·105) — the number of elements in Ivan's array.

The second line contains a sequence consisting of distinct integers a1, a2, ..., an (1 ≤ ai ≤ 109) — Ivan's array.

Output

Print representation of the given array in the form of one or more increasing sequences in accordance with the algorithm described above. Each sequence must be printed on a new line.

Examples

Input

5
1 3 2 5 4


Output

1 3 5 
2 4 


Input

4
4 3 2 1


Output

4 
3 
2 
1 


Input

4
10 30 50 101


Output

10 30 50 101 
#include <bits/stdc++.h>
static struct FASTIO {
  char READ_CHARACTER;
  bool REMAINING_CHARACTER = false;
  inline void ignore();
  inline void flush();
  template <typename T>
  inline bool READ_INT(T &x);
  template <typename T>
  inline bool READ_STRING(T &x);
  template <size_t N>
  inline bool READ_CHAR_ARRAY(char (&x)[N]);
  template <size_t N>
  inline bool READ_VAR(char (&x)[N]);
  template <typename T>
  inline bool READ_CHAR(T &x);
  inline bool READ_CHAR_ARRAY(char *&x);
  inline bool READ_GETLINE(std::string &x);
  template <typename T>
  inline bool READ_FLOAT(T &x);
  template <typename T>
  inline bool READ_DOUBLE(T &x);
  template <std::size_t N>
  inline bool READ_BITSET(std::bitset<N> &bit);
  template <std::size_t N>
  inline bool READ_VAR(std::bitset<N> &bit);
  inline bool READ_VAR(bool &x);
  inline bool READ_VAR(short int &x);
  inline bool READ_VAR(int &x);
  inline bool READ_VAR(long int &x);
  inline bool READ_VAR(long long int &x);
  inline bool READ_VAR(unsigned short int &x);
  inline bool READ_VAR(unsigned int &x);
  inline bool READ_VAR(unsigned long &x);
  inline bool READ_VAR(unsigned long long &x);
  inline bool READ_VAR(std::string &x);
  inline bool READ_VAR(char &x);
  inline bool READ_VAR(char *&x);
  inline bool READ_VAR(float &x);
  inline bool READ_VAR(double &x);
  inline bool READ_VAR(long double &x);
  template <typename T>
  inline void WRITE_INT(T x);
  inline void WRITE_STRING(std::string &x);
  inline void WRITE_CHAR(char x);
  inline void WRITE_CHAR_ARRAY(const char *x);
  inline void WRITE_FLOAT(float x);
  template <typename T>
  inline void WRITE_DOUBLE(T x);
  inline void WRITE_VAR(bool x);
  inline void WRITE_VAR(short int x);
  inline void WRITE_VAR(int x);
  inline void WRITE_VAR(long int x);
  inline void WRITE_VAR(long long int x);
  inline void WRITE_VAR(unsigned short int x);
  inline void WRITE_VAR(unsigned int x);
  inline void WRITE_VAR(unsigned long x);
  inline void WRITE_VAR(unsigned long long x);
  inline void WRITE_VAR(char x);
  inline void WRITE_VAR(const char *x);
  inline void WRITE_VAR(std::string &x);
  inline void WRITE_VAR(float x);
  inline void WRITE_VAR(double x);
  inline void WRITE_VAR(long double x);
  template <std::size_t N>
  inline void WRITE_VAR(std::bitset<N> &bit);
  template <std::size_t N>
  inline void WRITE_BITSET(std::bitset<N> &bit);
} __FIO__;
using namespace std;
inline bool eq(double a, double b) { return fabs(a - b) < 1e-9; }
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int &n, int b) { n |= two(b); }
inline void unset_bit(int &n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
  int res = 0;
  while (n && ++res) n -= n & (-n);
  return res;
}
const int N = 200001;
int arr[N];
vector<int> bak;
vector<vector<int>> ans;
int main() {
  0;
  0;
  0;
  ;
  int n;
  __FIO__.READ_VAR(n);
  ans.resize(n);
  bak.resize(n, -1);
  for (int i = 0; i < (n); ++i) __FIO__.READ_VAR(arr[i]);
  for (int i = 0; i < (n); ++i) {
    int pos =
        (int)(upper_bound(bak.begin(), bak.end(), arr[i], greater<int>()) -
              bak.begin());
    ans[pos].push_back(arr[i]);
    bak[pos] = arr[i];
  }
  for (int i = 0; i < (n); ++i) {
    if (ans[i].size()) {
      for (int j = 0; j < (ans[i].size()); ++j) {
        __FIO__.WRITE_VAR(ans[i][j]), __FIO__.WRITE_VAR(' ');
      }
      __FIO__.WRITE_VAR('\n');
    }
  }
  return 0;
}
inline void FASTIO::ignore() {
  if (REMAINING_CHARACTER == true)
    REMAINING_CHARACTER = false;
  else
    READ_CHARACTER = getchar();
}
inline void FASTIO::flush() { fflush(stdout); }
template <typename T>
inline bool FASTIO::READ_INT(T &x) {
  x = 0;
  T sig = 1;
  if (!REMAINING_CHARACTER)
    READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
  else
    REMAINING_CHARACTER = false;
  while (!isdigit(READ_CHARACTER) && READ_CHARACTER != EOF)
    sig = (READ_CHARACTER == '-' ? -sig : sig), READ_CHARACTER = getchar();
  if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
  while (isdigit(READ_CHARACTER))
    x = x * 10 + READ_CHARACTER - '0', READ_CHARACTER = getchar();
  x *= sig;
  REMAINING_CHARACTER = true;
  return true;
}
template <typename T>
inline bool FASTIO::READ_STRING(T &x) {
  x = "";
  if (!REMAINING_CHARACTER)
    READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
  else
    REMAINING_CHARACTER = false;
  while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
          READ_CHARACTER == ' '))
    READ_CHARACTER = getchar();
  if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
  while ((READ_CHARACTER != '\n' && READ_CHARACTER != '\t' &&
          READ_CHARACTER != ' ' && READ_CHARACTER != EOF))
    x += READ_CHARACTER, READ_CHARACTER = getchar();
  REMAINING_CHARACTER = true;
  return true;
}
inline bool FASTIO::READ_GETLINE(std::string &x) {
  x = "";
  if (!REMAINING_CHARACTER)
    READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
  else
    REMAINING_CHARACTER = false;
  if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
  while ((READ_CHARACTER != '\n' && READ_CHARACTER != EOF))
    x += READ_CHARACTER, READ_CHARACTER = getchar();
  REMAINING_CHARACTER = false;
  return true;
}
template <typename T>
inline bool FASTIO::READ_CHAR(T &x) {
  if (!REMAINING_CHARACTER)
    READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
  else
    REMAINING_CHARACTER = false;
  if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
  while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
          READ_CHARACTER == ' '))
    READ_CHARACTER = getchar();
  x = READ_CHARACTER;
  REMAINING_CHARACTER = false;
  return true;
}
template <size_t N>
inline bool FASTIO::READ_CHAR_ARRAY(char (&x)[N]) {
  if (!REMAINING_CHARACTER)
    READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
  else
    REMAINING_CHARACTER = false;
  while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
          READ_CHARACTER == ' '))
    READ_CHARACTER = getchar();
  if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
  char *ptr = &x[0];
  while ((READ_CHARACTER != '\n' && READ_CHARACTER != '\t' &&
          READ_CHARACTER != ' ' && READ_CHARACTER != EOF))
    *ptr++ = READ_CHARACTER, READ_CHARACTER = getchar();
  *ptr = '\0', REMAINING_CHARACTER = true;
  return true;
}
inline bool FASTIO::READ_CHAR_ARRAY(char *&x) {
  std::string y;
  if (READ_STRING(y) == false) return false;
  x = new char[(int)y.size() + 1];
  strcpy(x, y.c_str());
  return true;
}
template <typename T>
inline bool FASTIO::READ_FLOAT(T &x) {
  return (scanf("%f", &x) != EOF);
}
template <typename T>
inline bool FASTIO::READ_DOUBLE(T &x) {
  double y;
  if (scanf("%lf", &y) == EOF) return false;
  x = y;
  return true;
}
template <std::size_t N>
inline bool FASTIO::READ_BITSET(std::bitset<N> &x) {
  if (!REMAINING_CHARACTER)
    READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
  else
    REMAINING_CHARACTER = false;
  while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
          READ_CHARACTER == ' '))
    READ_CHARACTER = getchar();
  if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
  int i = 0;
  REMAINING_CHARACTER = true;
  while (READ_CHARACTER == '0' || READ_CHARACTER == '1')
    x[i++] = READ_CHARACTER - '0', READ_CHARACTER = getchar();
  return true;
}
inline bool FASTIO::READ_VAR(short int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(long int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(long long int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned short int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned long &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned long long &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(std::string &x) { return READ_STRING(x); }
inline bool FASTIO::READ_VAR(char &x) { return READ_CHAR(x); }
template <size_t N>
inline bool FASTIO::READ_VAR(char (&x)[N]) {
  return READ_CHAR_ARRAY(x);
}
inline bool FASTIO::READ_VAR(char *&x) { return READ_CHAR_ARRAY(x); }
inline bool FASTIO::READ_VAR(float &x) { return READ_FLOAT(x); }
inline bool FASTIO::READ_VAR(double &x) { return READ_DOUBLE(x); }
inline bool FASTIO::READ_VAR(long double &x) { return READ_DOUBLE(x); }
template <std::size_t N>
inline bool FASTIO::READ_VAR(std::bitset<N> &x) {
  return READ_BITSET(x);
}
template <typename T>
inline void FASTIO::WRITE_INT(T x) {
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  char writeBuffer[20], *writePtr = writeBuffer;
  do {
    *writePtr++ = '0' + x % 10;
    x /= 10;
  } while (x);
  do {
    putchar(*--writePtr);
  } while (writePtr > writeBuffer);
}
inline void FASTIO::WRITE_CHAR(char x) { putchar(x); }
inline void FASTIO::WRITE_CHAR_ARRAY(const char *x) {
  while (*x != '\0') putchar(*x++);
}
inline void FASTIO::WRITE_STRING(std::string &x) {
  for (char c : x) putchar(c);
}
inline void FASTIO::WRITE_FLOAT(float x) { printf("%f", x); }
template <typename T>
inline void FASTIO::WRITE_DOUBLE(T x) {
  printf("%lf", (double)x);
}
template <std::size_t N>
inline void FASTIO::WRITE_BITSET(std::bitset<N> &x) {
  for (int i = (int)x.size() - 1; i >= 0; i--) putchar(x[i] + 48);
}
inline void FASTIO::WRITE_VAR(bool x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(short int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(long int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(long long int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned short int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned long x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned long long x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(std::string &x) { WRITE_STRING(x); }
inline void FASTIO::WRITE_VAR(char x) { WRITE_CHAR(x); }
inline void FASTIO::WRITE_VAR(const char *x) { WRITE_CHAR_ARRAY(x); }
inline void FASTIO::WRITE_VAR(float x) { WRITE_FLOAT(x); }
inline void FASTIO::WRITE_VAR(double x) { WRITE_DOUBLE(x); }
inline void FASTIO::WRITE_VAR(long double x) { WRITE_DOUBLE(x); }
template <std::size_t N>
inline void FASTIO::WRITE_VAR(std::bitset<N> &x) {
  WRITE_BITSET(x);
}
