#include <vector>

template <typename T, typename F>
class segment_tree {
public:
	segment_tree(int n, const F& f, const T& e)
		: f(f), e(e)
	{
		sz = 1;
		while (sz < n) {
			sz *= 2;
		}
		dat.assign(2 * sz, e);
	}

	void update(int i, const T& x) {
		i += sz;
		dat[i] = x;
		while (i > 1) {
			i /= 2;
			dat[i] = f(dat[2 * i + 0], dat[2 * i + 1]);
		}
	}

	T query(int i) const {
		return dat[i + sz];
	}

	T query(int a, int b) const {
		T l = e;
		T r = e;
		a += sz;
		b += sz;
		for (; a < b; a /= 2, b /= 2) {
			if (a & 1) {
				l = f(l, dat[a]);
				++a;
			}
			if (b & 1) {
				--b;
				r = f(dat[b], r);
			}
		}
		return f(l, r);
	}

private:
	F f;
	T e;
	int sz;
	std::vector<T> dat;
};

template <typename T>
long long inversion_number(const std::vector<T>& a)
{
	const int N = a.size();

	auto f = [](T a, T b) {
		return a + b;
	};
	T e = 0;
	segment_tree<T, decltype(f)> seg(N, f, e);

	long long ans = 0;
	for (int i = 0; i < N; ++i) {
		ans += i - seg.query(0, a[i] + 1);
		seg.update(a[i], seg.query(a[i]) + 1);
	}
	return ans;
}

#include <iostream>

using namespace std;

int main()
{
	int N;
	cin >> N;
	vector<int> a(N);
	for (auto& x : a) {
		cin >> x;
	}
	long long ans = inversion_number(a);
	cout << ans << endl;
	for (int i = 0; i + 1 < N; ++i) {
		ans += N - 1 - 2 * a[i];
		cout << ans << endl;
	}
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long ll;

template<typename T>
struct BIT {
  vector<T> data;
  BIT() {}
  BIT(int n) : data(n+1, 0) {}
  void init(int n) { data.assign(n+1, 0); }
  T sum(int ed) const {
    for(T res(0); ; ed &= ed-1) if(ed) res += data[ed]; else return res;
  }
  T total(void) const { return sum(data.size()-1); }
  void add(int i, const T& x) {
    for(++i; i < (int)data.size(); i += i&-i) data[i] += x;
  }
};

int as[300000+10];

int main(void) {
  int n;
  scanf("%d", &n);
  REP(i, n) {
    scanf("%d", &as[i]);
  }
  ll res = 0;
  BIT<ll> bit(n);
  REP(i, n) {
    res += bit.sum(n) - bit.sum(as[i]);
    bit.add(as[i], 1);
  }
  REP(i, n) {
    printf("%lld\n", res);
    int v = as[i];
    res += n-v-1;
    res -= v;
  }
  return 0;
}
