#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int INF = 1e9;


#define dbg(x) "(" << #x <<": " << (x) << ") "
template<typename Ostream, typename Cont>
enable_if_t<is_same_v<Ostream,ostream>, Ostream&> 
operator<<(Ostream& os, const Cont& v){
	os<<"[";
	for(auto& x:v){os<<x<<", ";}
	return os<<"]";
}
template<typename ...Ts>
ostream& operator<<(ostream& os, const pair<Ts...>& p){
	return os<<"{"<<p.first<<", "<<p.second<<"}";
}

// Fenwick Tree for summation
struct fenwick_tree {
  int n;
  vector<ll> bits;
  fenwick_tree(int n) : n(n), bits(n+1) {}

  // add delta to node v
  void update(int v, int delta) {
    for (++v; v <= n; v += v&(-v)) 
      bits[v] += delta;
  }

  // get prefix sum of range [0,r]
  ll query(int r) {
    ll res = 0;
    for (++r; r > 0; r -= r&(-r))
      res += bits[r];
    return res;
  }
};

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);

  int n;
  cin >> n;
  
  vector<tuple<int,int,int>> intervals(n);
  vector<int> A(n*2);
  for (int i=0;i<n;i++){
    int l,r;
    cin >> l >> r;
    --l,--r;
    A[l] = i, A[r] = i;
    intervals[i]={l,r,i};
  }

  vector<ll> ans(n);
  vector<int> vis(n);
  fenwick_tree ft(n*2+1);
  sort(begin(intervals), end(intervals));
  for (int i=0;i<n;i++){
    auto [l,r,j] = intervals[i];
    ft.update(r,1);
  }
  for (int i=0;i<n;i++){
    auto [l,r,j] = intervals[i];
    ft.update(r,-1);
    ans[j] += ft.query(r) - ft.query(l);
  }
  for (int i=0;i<n;i++){
    auto [l,r,j] = intervals[i];
    ft.update(r,1);
  }
  for (int i=n-1;i>=0;i--){
    auto [l,r,j] = intervals[i];
    ft.update(r,-1);
    ans[j] -= ft.query(2*n) - ft.query(r);
  }


  auto calc = [&](vector<int>& order, bool inv) {
    map<int, int> stack;
    set<int> indices;
    map<int, int> zombies;
    ll kill_sum = 0;
    int kill = 0;
    for (int i : order) {
      // cout << dbg(i) dbg(A[i]) dbg(kill_sum) dbg(kill) dbg(zombies.size())<< "\n";
      if (!stack.count(A[i])) {
        stack.insert({A[i],i});
        indices.insert(inv ? -i : i);
        ans[A[i]] += 2*zombies.size() + kill + kill_sum;
      } else {
        indices.erase(inv ? -stack[A[i]] : stack[A[i]]);
        zombies.insert({inv ? -i : i, A[i]});
        stack.erase(A[i]);
        ans[A[i]] += stack.size();
        if (stack.empty()) {
          kill = 0;
          kill_sum = 0;
        } else {
          for (auto it = zombies.begin(); it != zombies.end();) {
            if (it->first < *indices.begin()) {
              it = zombies.erase(it);
              kill++;
              kill_sum += 1;
            } else {
              break;
            }
          }
        }
      }
    }
  };
  vector<int> order(2*n);
  iota(begin(order), end(order), 0);
  calc(order, false);
  reverse(begin(order), end(order));
  calc(order, true);


  for (int i=0;i<n;i++){
    cout << ans[i] << "\n";
  }
}