#include<set>

 #include<cmath>

 #include<queue>

 #include<vector>

 #include<cstdio>

 #include<cstring>

 #include<iostream>

 #include<algorithm>

 #define trav(u,i) for(int i=front[u];i;i=e[i].nxt)

 #define FOR(a,b,c) for(int a=(b);a<=(c);a++)

 using namespace std;

 typedef long long ll;

 const int N = 5e5+; 

 ll read() {

     char c=getchar();

     ll f=,x=;

     while(!isdigit(c)) {

         if(c=='-') f=-; c=getchar();

     }

     while(isdigit(c))

         x=x*+c-'',c=getchar();

     return x*f;

 }

 struct Node *null;

 struct Node {

     int v,s,rev;

     Node *ch[],*fa;

     void init(int x) {

         v=x;

         s=rev=;

         ch[]=ch[]=fa=null;

     }

     void pushdown() {

         if(rev) {

             swap(ch[],ch[]);

             ch[]->rev^=; ch[]->rev^=;

             rev=;

         }

     }

     void maintain() {

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

     }

 } nodepool[N],*node[N];

 void rot(Node* o,int d) {

     Node *k=o->ch[d],*tmp=null;

     o->ch[d]=k->ch[d^];

     if((tmp=k->ch[d^])!=null) tmp->fa=o;

     k->ch[d^]=o;

     if((tmp=o->fa)!=null) tmp->ch[tmp->ch[]==o]=k;

     o->fa=k; k->fa=tmp;

 }

 Node *st[N<<];

 void up_push(Node* u) {

     int top=;

     while(u!=null)

         st[++top]=u,u=u->fa;

     while(top)

         st[top--]->pushdown();

 }

 void splay(Node* o,Node* des=null) {

     up_push(o);

     Node *nf,*nff;

     while(o!=des && (nf=o->fa)!=des) {

         nff=nf->fa;

         if(nff==des) rot(nf,nf->ch[]==o),nf->maintain();

         else {

             int d1=nf->ch[]==o,d2=nff->ch[]==nf;

             if(d1==d2) rot(nff,d2),rot(nf,d1);

             else rot(nf,d1),rot(nff,d2);

             nff->maintain(),nf->maintain();

         }

     }

     o->maintain();

 }

 void reverse(Node* o) {

     swap(o->ch[],o->ch[]);

     o->ch[]->rev^=;

     o->ch[]->rev^=;

 }

 Node* getbound(Node* o,int d) {

     o->pushdown();

     if(o->ch[]==null&&o->ch[]==null) return o;

     if(o->ch[d]!=null) return getbound(o->ch[d],d);

     else return o;

 }

 void merge(Node* u,Node* v) {

     if(u->ch[]==null) u->ch[]=v;

     else {

         u=getbound(u,);

         splay(u);

         u->ch[]=v;

     }

     v->fa=u; u->maintain();

 }

 int n,a[N];

 Node* build(int l,int r,Node* fa) {

     if(l>r) return null;

     int mid=l+r>>;

     Node* o=node[a[mid]];

     o->fa=fa;

     o->v=a[mid];

     o->ch[]=build(l,mid-,o);

     o->ch[]=build(mid+,r,o);

     o->maintain();

     return o;

 }

 struct snode {

     int a,rank;

     bool operator < (const snode& rhs) const {

         return a<rhs.a||(a==rhs.a&&rank<rhs.rank);

     }

 } nodes[N];

 int main()

 {

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

     //freopen("out.out","w",stdout);

     while(n=read(),n) {

         null=new Node();

         FOR(i,,n) {

             a[i]=read();

             nodes[i]=(snode){a[i],i};

             node[i]=&nodepool[i];

             nodepool[i].init();

         }

         sort(nodes+,nodes+n+);

         FOR(i,,n) a[nodes[i].rank]=i;

         build(,n,null);

         FOR(i,,n-) {

             Node* o=node[i];

             splay(o);

             printf("%d ",o->ch[]->s+i);

             Node *lc=o->ch[],*rc=o->ch[];

             o->ch[]=o->ch[]=null;

             lc->fa=rc->fa=null;

             if(lc!=null) {

                 lc->pushdown();

                 if(rc!=null) rc->pushdown();

                 reverse(lc);

                 merge(lc,rc);

             }

         }

         printf("%d\n",n);

     }

     return ;

 }