#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb(x) push_back(x)
#define all(x) x.begin(), x.end()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
//const ll MOD = 1e9+7;
const ll MOD = 998244353;
const int inf = 1e9;
const ll INF = 1e18;
const ld EPS = 1e-10;

template<ll mod> struct Mod_Int{
    ll x;
    Mod_Int() {}
    Mod_Int(ll y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod){}

    Mod_Int &operator += (const Mod_Int &p) {
        x = (x + p.x) % mod;
        return *this;
    }

    Mod_Int &operator -= (const Mod_Int &p) {
        x = (x + mod - p.x) % mod;
        return *this;
    }

    Mod_Int &operator *= (const Mod_Int &p) {
        x = (x * p.x) % mod;
        return *this;
    }

    Mod_Int &operator /= (const Mod_Int &p) {
        *this *= p.inverse();
        return *this;
    }

    Mod_Int operator -() const {return Mod_Int(-x);}

    Mod_Int operator + (const Mod_Int &p) const {return Mod_Int(*this) += p;}

    Mod_Int operator - (const Mod_Int &p) const {return Mod_Int(*this) -= p;}

    Mod_Int operator * (const Mod_Int &p) const {return Mod_Int(*this) *= p;}

    Mod_Int operator / (const Mod_Int &p) const {return Mod_Int(*this) /= p;}

    bool operator == (const Mod_Int &p) const {return x == p.x;}

    bool operator != (const Mod_Int &p) const {return x != p.x;}

    Mod_Int pow(ll n) const{
        Mod_Int now = *this, ret = 1;
        while(n > 0){
            if(n & 1) ret *= now;
            now *= now, n >>= 1;
        }
        return ret;
    }

    Mod_Int inverse() const{
        return pow(mod-2);
    }
};

using mint = Mod_Int<MOD>;
const int MAX_N = 1e5;
mint fac[MAX_N+1];

void init(){
    fac[0] = 1;
    rep2(i, 1, MAX_N){
        fac[i] = fac[i-1]*mint(i);
    }
}

mint comb(mint n, mint k){
    return fac[n.x]/(fac[n.x-k.x]*fac[k.x]);
}

mint perm(mint n, mint k){
    return fac[n.x]/fac[n.x-k.x];
}

template<typename T> struct Binary_Indexed_Tree{
    vector<T> bit;
    //要素数N(0-indexed)のBITを構築
    Binary_Indexed_Tree(int N){
        bit.assign(N+1, 0);
    }
    //i番目の要素にx加える
    void add(int i, T x){
        for(i++; i < bit.size(); i += (i & -i)) bit[i] += x;
    }
    //sum(i)で[0,i)の和を取得
    T sum(int i){
        T res = 0;
        for(i = i; i > 0; i -= (i & -i)) res += bit[i];
        return res;
    }
    //query(l,r)で[l,r)の和を取得
    T query(int l, int r){
        return sum(r) - sum(l);
    }
    //初期化する
    void clear(){
        fill(bit.begin(), bit.end(), 0);
    }
};

int main(){
    int N;
    cin >> N;
    int x[N], y[N];
    map<int, int> mpx, mpy;
    rep(i, N){
        cin >> x[i] >> y[i];
        mpx[x[i]]++, mpy[y[i]]++;
    }
    int i = 0;
    for(auto &e: mpx){
        e.second = i, i++;
    }
    i = 0;
    for(auto &e: mpy){
        e.second = i, i++;
    }
    rep(i, N){
        x[i] = mpx[x[i]], y[i] = mpy[y[i]];
    }
    pii px[N], py[N];
    rep(i, N){
        px[i] = pii(x[i], i), py[i] = pii(y[i], i);
    }
    sort(px, px+N), sort(py, py+N);
    //点iが左から何番目か
    int id[N];
    rep(i, N) id[px[i].second] = i;
    Binary_Indexed_Tree<int> bit(N);
    int num[N][4];
    rep(i, N){
        int j = py[i].second, k = id[j];
        num[j][0] = bit.query(0, k);
        num[j][1] = bit.query(k+1, N);
        bit.add(k, 1);
    }
    bit.clear();
    sort(py, py+N, greater<pii>());
    rep(i, N){
        int j = py[i].second, k = id[j];
        num[j][2] = bit.query(0, k);
        num[j][3] = bit.query(k+1, N);
        bit.add(k, 1);
    }
    mint ans = 0;
    rep(i, N){
        mint t = 2;
        int A = num[i][0], B = num[i][1], C = num[i][2], D = num[i][3];
        ans += (t.pow(A)-1)*(t.pow(D)-1)*(t.pow(B+C));
        ans += (t.pow(B)-1)*(t.pow(C)-1)*(t.pow(A+D));
        ans -= (t.pow(A)-1)*(t.pow(B)-1)*(t.pow(C)-1)*(t.pow(D)-1);
        ans += t.pow(N-1);
    }
    cout << ans.x << endl;
}

Measured memory_bytes: 28416