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

using s64 = long long;

const int N = 2e5 + 5;
const int M = 4e5 + 5;
const int T = 1 << 20;

int n, m, cnt[M], lpos[M], rpos[M];
struct Seg{int l, r, k;}seg[N];
int siz[T], tag[T];
s64 sum[T], ans[N];

void build(int k = 1, int L = 0, int R = m) {
    tag[k] = 0;
    if (L + 1 == R) {
        siz[k] = cnt[L];
        sum[k] = siz[k] << 1;
        return;
    }
    int mid = L + R >> 1;
    build(k << 1, L, mid);
    build(k << 1 | 1, mid, R);
    siz[k] = siz[k << 1] + siz[k << 1 | 1];
    sum[k] = sum[k << 1] + sum[k << 1 | 1];
}

void addn(int k, int v) {
    tag[k] += v;
    sum[k] += s64(tag[k]) * siz[k];
}

void down(int k) {
    addn(k << 1, tag[k]);
    addn(k << 1 | 1, tag[k]);
    tag[k] = 0;
}

void add(int l, int r, int k = 1, int L = 0, int R = m) {
    if (l >= r || r <= L || R <= l) return;
    if (l <= L && R <= r) return addn(k, 1);
    down(k); int mid = L + R >> 1;
    add(l, r, k << 1, L, mid);
    add(l, r, k << 1 | 1, mid, R);
    sum[k] = sum[k << 1] + sum[k << 1 | 1];
}

s64 query(int l, int r, int k = 1, int L = 0, int R = m) {
    if (l >= r || r <= L || R <= l) return 0;
    if (l <= L && R <= r) return sum[k];
    down(k); int mid = L + R >> 1;
    return query(l, r, k << 1, L, mid) + query(l, r, k << 1 | 1, mid, R);
}

void solve() {
    sort(seg, seg + n, [](const Seg& a, const Seg& b){
        return a.l == b.l ? a.r > b.r : a.l < b.l;
    });
    fill(lpos, lpos + m + 1, m + 1);
    fill(rpos, rpos + m + 1, -1);
    for (int i = 0, j = 0, curR = -1; i < m; ++i) {
        if (j < n && seg[j].l == i && seg[j].r > curR) {
            if (curR >= 0) rpos[curR] = i;
            lpos[curR = seg[j].r] = i;
        }
        while (j < n && seg[j].l == i) ++j;
        if (curR == i) {rpos[curR] = i + 1; curR = -1;}
        if (curR >= 0) lpos[curR] = min(lpos[curR], lpos[i]);
    }
    fill(cnt, cnt + m + 1, 0);
    for (int i = 0; i < n; ++i) ++cnt[seg[i].r];
    build();
    for (int i = 0, j = 0, l = 0; j < n && i < m; ++i) {
        while (j < n && seg[j].l == i) {
            ans[seg[j].k] += query(l, seg[j].l);
            // cerr << j << ' ' << seg[j].l << ' ' << seg[j].r << ' ' << ans[seg[j].k] << endl;
            ++j;
        }
        // cerr << i << ' ' << lpos[i] << ' ' << rpos[i] << endl;
        if (rpos[i] == i + 1) l = i + 1;
        else if (rpos[i] >= 0) {
            add(lpos[i], rpos[i]);
            // cerr << "ADD " << lpos[i] << ' ' << rpos[i] << endl;
        }
    }
    // cerr << endl;
}

void solveint() {
    sort(seg, seg + n, [](const Seg& a, const Seg& b){
        return a.r > b.r;
    });
    fill(cnt, cnt + m + 1, 0);
    static int lcnt[M] = {0};
    for (int i = 0; i < n; ++i) ++cnt[seg[i].r];
    for (int i = 1; i < m; ++i) cnt[i] += cnt[i - 1];
    for (int i = 0, j, now = 0, x = m; i < n; i = j) {
        for (j = i; j < n && seg[j].r == seg[i].r; ++j) ++lcnt[seg[j].l];
        for (; x > seg[i].r; --x) now -= lcnt[x];
        for (int k = i; k < j; ++k) {
            ans[seg[k].k] += cnt[seg[k].r] - (seg[k].l == 0 ? 0 : cnt[seg[k].l - 1]);
            ans[seg[k].k] += now;
        }
        now += j - i;
    }
}

void reverse() {
    for (int i = 0; i < n; ++i) {
        swap(seg[i].l, seg[i].r);
        seg[i].l = m - seg[i].l - 1;
        seg[i].r = m - seg[i].r - 1;
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);
    cin >> n; m = n << 1;
    for (int i = 0; i < n; ++i) {
        cin >> seg[i].l >> seg[i].r;
        --seg[i].l; --seg[i].r;
        seg[i].k = i;
    }
    solve();
    // for (int i = 0; i < n; ++i)
    //     cerr << ans[i] << " \n"[i + 1 == n];
    solveint();
    reverse();
    // for (int i = 0; i < n; ++i)
    //     cerr << ans[i] << " \n"[i + 1 == n];
    solve();
    // for (int i = 0; i < n; ++i)
    //     cerr << ans[i] << " \n"[i + 1 == n];
    for (int i = 0; i < n; ++i)
        cout << ans[i] - 1 << '\n';
}