/* 1890 */

 #include <iostream>

 #include <string>

 #include <map>

 #include <queue>

 #include <set>

 #include <stack>

 #include <vector>

 #include <deque>

 #include <algorithm>

 #include <cstdio>

 #include <cmath>

 #include <ctime>

 #include <cstring>

 #include <climits>

 #include <cctype>

 #include <cassert>

 #include <functional>

 #include <iterator>

 #include <iomanip>

 using namespace std;

 //#pragma comment(linker,"/STACK:102400000,1024000")

 #define sti                set<int>

 #define stpii            set<pair<int, int> >

 #define mpii            map<int,int>

 #define vi                vector<int>

 #define pii                pair<int,int>

 #define vpii            vector<pair<int,int> >

 #define rep(i, a, n)     for (int i=a;i<n;++i)

 #define per(i, a, n)     for (int i=n-1;i>=a;--i)

 #define clr                clear

 #define pb                 push_back

 #define mp                 make_pair

 #define fir                first

 #define sec                second

 #define all(x)             (x).begin(),(x).end()

 #define SZ(x)             ((int)(x).size())

 #define lson            l, mid, rt<<1

 #define rson            mid+1, r, rt<<1|1

 #define grandlson        ch[ch[root][1]][0]

 typedef struct node_t {

     int id, val;

     node_t() {}

     friend bool operator<(const node_t& a, const node_t& b) {

         if (a.val != b.val)

             return a.val < b.val;

         return a.id < b.id;

     }

 } node_t;

 const int maxn = 1e5+;

 int pre[maxn], ch[maxn][], size[maxn], rev[maxn];

 node_t nd[maxn];

 int root, tot, n;

 int ans[maxn];

 void newNode(int& r, int k, int fa) {

     r = k;

     pre[r] = fa;

     ch[r][] = ch[r][] = ;

     size[r] = ;

     rev[r] = ;

 }

 void PushUp(int r) {

     size[r] = size[ch[r][]] + size[ch[r][]] + ;

 }

 void UpdateRev(int r) {

     if (r == )    return ;

     swap(ch[r][], ch[r][]);

     rev[r] ^= ;

 }

 void PushDown(int r) {

     if (rev[r]) {

         UpdateRev(ch[r][]);

         UpdateRev(ch[r][]);

         rev[r] = ;

     }

 }

 void Build(int& rt, int l, int r, int fa) {

     if (l > r)    return ;

     int mid = (l + r) >> ;

     newNode(rt, mid, fa);

     Build(ch[rt][], l, mid-, rt);

     Build(ch[rt][], mid+, r, rt);

     PushUp(rt);

 }

 void Rotate(int x, int d) {

     int y = pre[x];

     PushDown(y);

     PushDown(x);

     ch[y][d^] = ch[x][d];

     pre[ch[x][d]] = y;

     if (pre[y])

         ch[pre[y]][ch[pre[y]][]==y] = x;

     pre[x] = pre[y];

     ch[x][d] = y;

     pre[y] = x;

     PushUp(y);

 }

 void Splay(int r, int goal) {

     PushDown(r);

     while (pre[r] != goal) {

         if (pre[pre[r]] == goal) {

             PushDown(pre[r]);

             PushDown(r);

             Rotate(r, ch[pre[r]][]==r);

         } else {

             PushDown(pre[pre[r]]);

             PushDown(pre[r]);

             PushDown(r);

             int y = pre[r];

             int d = ch[pre[y]][]==y;

             if (ch[y][d] == r) {

                 Rotate(r, d^);

                 Rotate(r, d);

             } else {

                 Rotate(y, d);

                 Rotate(r, d);

             }

         }

     }

     PushUp(r);

     if (goal == )

         root = r;

 }

 int kth(int r, int k) {

     int sz = size[ch[r][]] + ;

     PushDown(r);

     if (k == sz)

         return r;

     if (k < sz)

         return kth(ch[r][], k);

     else

         return kth(ch[r][], k-sz);

 }

 int getNext(int rt) {

     PushDown(rt);

     if (ch[rt][] == )        return -;

     rt = ch[rt][];

     while (ch[rt][]) {

         rt = ch[rt][];

         PushDown(rt);

     }

     return rt;

 }

 void init() {

     ch[root][] = ch[root][] = size[root] = rev[root] = ;

     newNode(root, n+, );

     newNode(ch[root][], n+, root);

     Build(grandlson, , n, ch[root][]);

     PushUp(ch[root][]);

     PushUp(root);

 }

 void inorder(int rt) {

     if (rt == )    return ;

     inorder(ch[rt][]);

     printf("rt = %d, lson = %d, rson = %d, fa = %d, sz = %d, rev = %d\n",

         rt, ch[rt][], ch[rt][], pre[rt], size[rt], rev[rt]);

     inorder(ch[rt][]);

 }

 int main() {

     ios::sync_with_stdio(false);

     #ifndef ONLINE_JUDGE

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

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

     #endif

     int r;

     while (scanf("%d", &n)!=EOF && n) {

         rep(i, , n+) {

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

             nd[i].id = i;

         }

         init();

         sort(nd+, nd++n);

         rep(i, , n+) {

             r = nd[i].id;

             Splay(r, );

             ans[i] = size[ch[root][]];

             Splay(kth(root, i), );

             Splay(getNext(r), root);

             UpdateRev(grandlson);

         }

         rep(i, , n+) {

             printf("%d", ans[i]);

             if (i == n)

                 putchar('\n');

             else

                 putchar(' ');

         }

     }

     #ifndef ONLINE_JUDGE

         printf("time = %d.\n", (int)clock());

     #endif

     return ;

 }