#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 500000;
const int INF = 1e8;
int N;
int arr[MAX_N + 1], num[MAX_N + 1];
vector<pair<int, int> > vt;
set<int> st;
set<int>::iterator it;
struct SEG {
  struct NODE {
    int l, r;
    int mn, lazy;
  };
  vector<NODE> seg;
  int SZ;
  void add() { seg.push_back({-1, -1, INF, 0}); }
  void Init(int x) {
    SZ = x;
    add();
    init(0, 1, SZ);
  }
  void init(int idx, int s, int e) {
    if (s == e) return;
    seg[idx].l = seg.size();
    add();
    seg[idx].r = seg.size();
    add();
    init(seg[idx].l, s, (s + e) / 2);
    init(seg[idx].r, (s + e) / 2 + 1, e);
  }
  void Update(int x, int y) { update(0, 1, SZ, x, y); }
  void update(int idx, int s, int e, int x, int y) {
    if (s == e) {
      seg[idx].mn = y;
      return;
    }
    if (seg[idx].lazy != 0) {
      seg[seg[idx].l].mn += seg[idx].lazy;
      seg[seg[idx].l].lazy += seg[idx].lazy;
      seg[seg[idx].r].mn += seg[idx].lazy;
      seg[seg[idx].r].lazy += seg[idx].lazy;
      seg[idx].lazy = 0;
    }
    if (x <= (s + e) / 2) {
      update(seg[idx].l, s, (s + e) / 2, x, y);
    } else {
      update(seg[idx].r, (s + e) / 2 + 1, e, x, y);
    }
    seg[idx].mn = min(seg[seg[idx].l].mn, seg[seg[idx].r].mn);
  }
  void Add(int x, int y, int z) { add2(0, 1, SZ, x, y, z); }
  void add2(int idx, int s, int e, int x, int y, int z) {
    if (x <= s && e <= y) {
      seg[idx].mn += z;
      seg[idx].lazy += z;
      return;
    }
    if (x > e || y < s) return;
    if (seg[idx].lazy != 0) {
      seg[seg[idx].l].mn += seg[idx].lazy;
      seg[seg[idx].l].lazy += seg[idx].lazy;
      seg[seg[idx].r].mn += seg[idx].lazy;
      seg[seg[idx].r].lazy += seg[idx].lazy;
      seg[idx].lazy = 0;
    }
    add2(seg[idx].l, s, (s + e) / 2, x, y, z);
    add2(seg[idx].r, (s + e) / 2 + 1, e, x, y, z);
    seg[idx].mn = min(seg[seg[idx].l].mn, seg[seg[idx].r].mn);
  }
  int Find(int x, int y) { return find(0, 1, SZ, x, y); }
  int find(int idx, int s, int e, int x, int y) {
    if (x <= s && e <= y) {
      if (seg[idx].mn == 1) {
        while (s != e) {
          if (seg[idx].lazy != 0) {
            seg[seg[idx].l].mn += seg[idx].lazy;
            seg[seg[idx].l].lazy += seg[idx].lazy;
            seg[seg[idx].r].mn += seg[idx].lazy;
            seg[seg[idx].r].lazy += seg[idx].lazy;
            seg[idx].lazy = 0;
          }
          if (seg[seg[idx].l].mn == 1) {
            idx = seg[idx].l;
            e = (s + e) / 2;
          } else {
            idx = seg[idx].r;
            s = (s + e) / 2 + 1;
          }
        }
        return s;
      } else {
        return N + 1;
      }
    }
    if (x > e || y < s) return N + 1;
    if (seg[idx].lazy != 0) {
      seg[seg[idx].l].mn += seg[idx].lazy;
      seg[seg[idx].l].lazy += seg[idx].lazy;
      seg[seg[idx].r].mn += seg[idx].lazy;
      seg[seg[idx].r].lazy += seg[idx].lazy;
      seg[idx].lazy = 0;
    }
    int t = find(seg[idx].l, s, (s + e) / 2, x, y);
    if (t != N + 1) return t;
    return find(seg[idx].r, (s + e) / 2 + 1, e, x, y);
  }
} Seg1, Seg2;
int tree[MAX_N + 1];
int d[MAX_N + 1];
void Update(int x, int y) {
  while (x <= N) {
    tree[x] += y;
    x += (x & -x);
  }
}
int Sum(int x) {
  int ret = 0;
  while (x > 0) {
    ret += tree[x];
    x -= (x & -x);
  }
  return ret;
}
void change(int x, int y) {
  Update(x, -d[x]);
  d[x] = y;
  Update(x, d[x]);
}
void add(int x) {
  int n = Sum(num[x]);
  if (n == arr[x]) {
    st.insert(num[x]);
    return;
  }
  if (arr[x] < n) {
    change(num[x], -1);
    n = arr[x] - n;
    int t = Seg2.Find(num[x], N);
    it = st.lower_bound(num[x]);
    if (it != st.end() && (*it) < t) {
      t = (*it);
      st.erase(it);
      change(t, +1);
      Seg1.Add(num[x] + 1, t, 1);
      Seg2.Add(num[x] + 1, t, -1);
      Seg1.Update(t, 1);
    } else {
      if (t != N + 1) Seg2.Update(t, INF);
      Seg1.Add(num[x] + 1, t, 1);
      Seg2.Add(num[x] + 1, t, -1);
      if (t != N + 1) {
        st.insert(t);
        change(t, 0);
      }
    }
    Seg2.Update(num[x], -n);
  } else {
    change(num[x], 1);
    n = arr[x] - n;
    int t = Seg1.Find(num[x], N);
    it = st.lower_bound(num[x]);
    if (it != st.end() && (*it) < t) {
      t = (*it);
      st.erase(it);
      change(t, -1);
      Seg1.Add(num[x] + 1, t, -1);
      Seg2.Add(num[x] + 1, t, 1);
      Seg2.Update(t, 1);
    } else {
      if (t != N + 1) Seg1.Update(t, INF);
      Seg1.Add(num[x] + 1, t, -1);
      Seg2.Add(num[x] + 1, t, 1);
      if (t != N + 1) {
        st.insert(t);
        change(t, 0);
      }
    }
    Seg1.Update(num[x], n);
  }
}
int main() {
  scanf("%d", &N);
  Seg1.Init(N);
  Seg2.Init(N);
  for (int i = 1; i <= N; i++) {
    scanf("%d", &arr[i]);
    vt.push_back({arr[i], i});
  }
  sort(vt.begin(), vt.end());
  for (int i = 0; i < vt.size(); i++) {
    num[vt[i].second] = i + 1;
  }
  for (int i = 1; i <= N; i++) {
    add(i);
    printf("%d\n", Sum(N));
  }
}
