#include<cstdio>

 #include<cstdlib>

 #include<iostream>

 #include<algorithm>

 using std::sort;

 using std::swap;

 const int Max_N = ;

 struct node{

     int val, pos;

 }rec[];

 inline bool cmp(const node &a, const node &b){

     if (a.val == b.val) return a.pos < b.pos;

     return a.val < b.val;

 }

 struct Node{

     int v, s, rsz, rev;

     Node *pre, *ch[];

     inline void set(int _v = -, int _s = , Node *p = NULL){

         v = _v, s = _s, rev = rsz = ;

         pre =  ch[] = ch[] = p;

     }

     inline void update(){

         rev ^= ;

         swap(ch[], ch[]);

     }

     inline void push_up(){

         s = ch[]->s + ch[]->s + ;

         rsz = ch[]->rsz + ch[]->rsz;

         if (v != -) rsz++;

     }

     inline void push_down(){

         if (rev != ){

             rev ^= ;

             ch[]->update();

             ch[]->update();

         }

     }

 };

 struct SplayTree{

     int top = ;

     Node *tail, *root, *null;

     Node stack[Max_N], *store[Max_N], *ptr[Max_N];

     void init(int n){

         top = ;

         tail = &stack[];

         null = tail++;

         null->set();

         root = newNode(-);

         root->ch[] = newNode(-);

         root->ch[]->pre = root;

         Node *x = built(, n);

         root->ch[]->ch[] = x;

         x->pre = root->ch[];

         root->ch[]->push_up();

         root->push_up();

     }

     inline Node *built(int l, int r){

         Node *p = null;

         if (l > r) return null;

         int mid = (l + r) >> ;

         p = newNode(rec[mid].val), ptr[mid] = p;

         p->ch[] = built(l, mid - );

         if (p->ch[] != null) p->ch[]->pre = p;

         p->ch[] = built(mid + , r);

         if (p->ch[] != null) p->ch[]->pre = p;

         p->push_up();

         return p;

     }

     inline Node *newNode(int v){

         Node *p = null;

         if (!top) p = tail++;

         else p = store[--top];

         p->set(v, , null);

         return p;

     }

     inline void rotate(Node *x, int d){

         Node *y = x->pre;

         y->push_down(), x->push_down();

         y->ch[!d] = x->ch[d];

         if (x->ch[d] != null) x->ch[d]->pre = y;

         x->pre = y->pre;

         if (y->pre != null) y->pre->ch[y->pre->ch[] != y] = x;

         x->ch[d] = y;

         y->pre = x;

         y->push_up();

         if (y == root) root = x;

     }

     inline void splay(Node *x, Node *f){

         for (; x->pre != f; x->push_down()){

             if (x->pre->pre == f){

                 rotate(x, x->pre->ch[] == x);

             } else {

                 Node *y = x->pre, *z = y->pre;

                 if (z->ch[] == y){

                     if (y->ch[] == x) rotate(y, ), rotate(x, );

                     else rotate(x, ), rotate(x, );

                 } else {

                     if (y->ch[] == x) rotate(y, ), rotate(x, );

                     else rotate(x, ), rotate(x, );

                 }

             }

         }

         x->push_up();

     }

     inline Node *select(Node *x, int k){

         int t = ;

         for (;;){

             x->push_down();

             t = x->ch[]->s;

             if (k == t + ) break;

             else if (k < t + ) x = x->ch[];

             else k -= t + , x = x->ch[];

         }

         return x;

     }

     inline void del(){

         Node *x = root;

         store[top++] = x;

         root = root->ch[];

         root->pre = null;

         splay(select(root, ), null);

         root->ch[] = x->ch[];

         root->ch[]->pre = root;

         root->push_up();

     }

     inline void solve(int n) {

         const int N = n + ;

         for (int i = ; i <= n; ++i) {

             scanf("%d", &rec[i].val);

             rec[i].pos = i;

         }

         init(n), sort(rec + , rec + n + , cmp);

         splay(root->ch[], null);

         for (int i = ; i <= n; i++){

             splay(ptr[rec[i].pos], null);

             root->ch[]->update();

             printf("%d", root->ch[]->rsz + i);

             if (i != n) printf(" ");

             del();

         }

         printf("\n");

     }

 }spt;

 int main(){

 #ifdef LOCAL

     freopen("in.txt", "r", stdin);

     freopen("out.txt", "w+", stdout);

 #endif

     int n;

     while (~scanf("%d", &n) && n) {

         spt.solve(n);

     }

     return ;

 }