#include <iostream>
#include <iomanip>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <array>
#include <tuple>
#include <string>
#include <algorithm>
#include <functional> // greater など
#include <cmath>
#include <numeric> // accumulate, gcd など
#include <stdexcept>
#include <bitset>
using namespace std;

#ifdef DEBUG
#include <cassert>
#else
#define assert(x)
#endif

#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (int)(b); i++)
typedef long long ll;

//////////////// //////////////// //////////////// //////////////// ////////////////
//////////////// //////////////// //////////////// //////////////// ////////////////

constexpr ll mod = 998244353;
ll modpow(ll a, ll b)
{
    if (b == 0)
    {
        return 1;
    }
    if (b & 1)
    {
        return (a * modpow(a, b - 1)) % mod;
    }
    else
    {
        auto half = modpow(a, b / 2);
        return (half * half) % mod;
    }
}

//////////////// //////////////// //////////////// //////////////// ////////////////
//////////////// //////////////// //////////////// //////////////// ////////////////

// 長さ fw.size() - 1 の列の累積和を管理
vector<int> fw;

// initialize with 0
void fw_init_0(int size)
{
    fw.resize(size + 1);
    fw.assign(size + 1, 0);
}

// 0-based
void fw_add(int i, int x)
{
    i++;
    while (i < fw.size())
    {
        fw[i] += x;
        i += i & -i;
    }
}

// 0-based, sum of [0,i)
int fw_sum1(int i)
{
    int ret = 0;
    while (i >= 1)
    {
        ret += fw[i];
        i -= i & -i;
    }
    return ret;
}

// 0-based, sum of [l,r)
int fw_sum(int l, int r)
{
    return fw_sum1(r) - fw_sum1(l);
}

int main()
{
    // 高速な入出力
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    // 浮動小数の表示の精度
    cout << setprecision(15);

    int n;
    cin >> n;
    vector<int> x_s(n), y_s(n), orig_x_s(n), orig_y_s(n);
    rep(i, n)
    {
        cin >> orig_x_s[i] >> orig_y_s[i];
        x_s[i] = orig_x_s[i];
        y_s[i] = orig_y_s[i];
    }
    sort(x_s.begin(), x_s.end());
    // x_s.erase(unique(x_s.begin(), x_s.end()), x_s.end());
    sort(y_s.begin(), y_s.end());
    // y_s.erase(unique(y_s.begin(), y_s.end()), y_s.end());

    vector<int> x_to_y(n, -1);
    // vector<int> y_to_x(n, -1);
    rep(i, n)
    {
        int x = lower_bound(x_s.begin(), x_s.end(), orig_x_s[i]) - x_s.begin();
        int y = lower_bound(y_s.begin(), y_s.end(), orig_y_s[i]) - y_s.begin();
        x_to_y[x] = y;
        // y_to_x[y] = x;
    }

    // non-empty only
    auto res1 = (modpow(2, n) - 1) * n % mod;
    auto res2 = (modpow(2, n) - 1 - n + mod) * 2 % mod;
    auto res3 = res2;
    ll res4 = 0;

    fw_init_0(n);
    rep(x, n)
    {
        int y = x_to_y[x];
        int a = fw_sum(0, y), b = fw_sum(y + 1, n);
        (res4 += modpow(2, a) - 1) %= mod;
        (res4 += modpow(2, b) - 1) %= mod;
#ifdef DEBUG
        clog << res4 << endl;
#endif

        fw_add(y, 1);
    }

    fw_init_0(n);
    for (int x = n - 1; x >= 0; x--)
    {
        int y = x_to_y[x];
        int a = fw_sum(0, y), b = fw_sum(y + 1, n);
        (res4 += modpow(2, a) - 1) %= mod;
        (res4 += modpow(2, b) - 1) %= mod;

        fw_add(y, 1);
    }

    cout << (res1 - res2 - res3 + res4 + 2 * mod) % mod << endl;

    return 0;
}


Measured memory_bytes: 7960