Buggy python submission (verdict: Time Limit Exceeded):
I = [int(_) for _ in open(0).read().split()]
N, X, Y = I[0], I[1::2], I[2::2]
mod = 998244353


def compress_coord(raw):
    i_v = {}
    v_i = {}
    for i, v in enumerate(sorted(set(raw))):
        i_v[i] = v
        v_i[v] = i
    return v_i, i_v


class BinaryIndexedTree():
    def __init__(self, n):
        """
        constructs binary indexed tree

        Parameters
        ----------
        n : int
            maximum index value
        """
        self.n = n
        self.dat = [0] * (n + 1)

    def sum(self, i):
        """
        returns the sum of [1, i]

        Parameters
        ----------
        i : int
            right end of the interval
        """
        s = 0
        while i:
            s += self.dat[i]
            i -= i & -i
        return s

    def add(self, i, x):
        """
        adds x to i-th element

        Parameters
        ----------
        i : int
            index
        x : int
            additional value
        """
        while i <= self.n:
            self.dat[i] += x
            i += i & -i


xi, _ = compress_coord(X)
yj, _ = compress_coord(Y)
X = [xi[x] for x in X]
Y = [yj[y] for y in Y]
LL = {}
LR = {}
RL = {}
RR = {}
sortXY = sorted(zip(X, Y))
bit = BinaryIndexedTree(N + 10)
for x, y in sortXY:
    LL[(x, y)] = bit.sum(y + 1)
    LR[(x, y)] = bit.sum(N + 1) - bit.sum(y + 1)
    bit.add(y + 1, 1)
bit = BinaryIndexedTree(N + 10)
for x, y in sortXY[::-1]:
    RL[(x, y)] = bit.sum(y + 1)
    RR[(x, y)] = bit.sum(N + 1) - bit.sum(y + 1)
    bit.add(y + 1, 1)
ans = N * (pow(2, N, mod) - 1) % mod
for x, y in zip(X, Y):
    ll = LL[(x, y)]
    lr = LR[(x, y)]
    rl = RL[(x, y)]
    rr = RR[(x, y)]
    a = pow(2, ll + lr, mod) - 1
    b = pow(2, rl + rr, mod) - 1
    c = pow(2, ll + rl, mod) - 1
    d = pow(2, lr + rr, mod) - 1
    e = pow(2, ll, mod) - 1
    f = pow(2, lr, mod) - 1
    g = pow(2, rl, mod) - 1
    h = pow(2, rr, mod) - 1
    ans -= a + b + c + d
    ans += e + f + g + h
    ans %= mod
print(ans)


Fixed submission:
I = [int(_) for _ in open(0).read().split()]
N, X, Y = I[0], I[1::2], I[2::2]
mod = 998244353


def compress_coord(raw):
    #i_v = {}
    v_i = {}
    for i, v in enumerate(sorted(set(raw))):
        #i_v[i] = v
        v_i[v] = i
    return v_i  #, i_v


class BinaryIndexedTree():
    def __init__(self, n):
        """
        constructs binary indexed tree

        Parameters
        ----------
        n : int
            maximum index value
        """
        self.n = n
        self.dat = [0] * (n + 1)

    def sum(self, i):
        """
        returns the sum of [1, i]

        Parameters
        ----------
        i : int
            right end of the interval
        """
        s = 0
        while i:
            s += self.dat[i]
            i -= i & -i
        return s

    def add(self, i, x):
        """
        adds x to i-th element

        Parameters
        ----------
        i : int
            index
        x : int
            additional value
        """
        while i <= self.n:
            self.dat[i] += x
            i += i & -i


xi = compress_coord(X)
yj = compress_coord(Y)
X = [xi[x] for x in X]
Y = [yj[y] for y in Y]
LL = [0] * (2 * N)
LR = [0] * (2 * N)
RL = [0] * (2 * N)
RR = [0] * (2 * N)
sortXY = sorted(zip(X, Y))
bit = BinaryIndexedTree(N + 10)
for x, y in sortXY:
    LL[x] = bit.sum(y + 1)
    LR[x] = bit.sum(N + 1) - bit.sum(y + 1)
    bit.add(y + 1, 1)
bit = BinaryIndexedTree(N + 10)
for x, y in sortXY[::-1]:
    RL[x] = bit.sum(y + 1)
    RR[x] = bit.sum(N + 1) - bit.sum(y + 1)
    bit.add(y + 1, 1)
ans = N * (pow(2, N, mod) - 1) % mod
for ll, lr, rl, rr in zip(LL, LR, RL, RR):
    a = pow(2, ll + lr, mod)
    b = pow(2, rl + rr, mod)
    c = pow(2, ll + rl, mod)
    d = pow(2, lr + rr, mod)
    e = pow(2, ll, mod)
    f = pow(2, lr, mod)
    g = pow(2, rl, mod)
    h = pow(2, rr, mod)
    ans -= a + b + c + d
    ans += e + f + g + h
    ans %= mod
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
I = [int(_) for _ in open(0).read().split()]
N, X, Y = I[0], I[1::2], I[2::2]
mod = 998244353


class SegmentTree():
    def __init__(self, array, f, ti):
        """
        Parameters
        ----------
        array : list
            to construct segment tree from
        f : func
            binary operation of the monoid
        ti : 
            identity element of the monoid
        """
        self.f = f
        self.ti = ti
        self.n = n = 2**(len(array).bit_length())
        self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
        for i in range(n - 1, 0, -1):  # build
            dat[i] = f(dat[i << 1], dat[i << 1 | 1])

    def update(self, p, v):  # set value at position p (0-indexed)
        f, n, dat = self.f, self.n, self.dat
        p += n
        dat[p] = v
        while p > 1:
            p >>= 1
            dat[p] = f(dat[p << 1], dat[p << 1 | 1])

    def query(self, l, r):  # result on interval [l, r) (0-indexed)
        f, ti, n, dat = self.f, self.ti, self.n, self.dat
        vl = vr = ti
        l += n
        r += n
        while l < r:
            if l & 1:
                vl = f(vl, dat[l])
                l += 1
            if r & 1:
                r -= 1
                vr = f(dat[r], vr)
            l >>= 1
            r >>= 1
        return f(vl, vr)


def compress_coord(raw):
    i_v = {}
    v_i = {}
    for i, v in enumerate(sorted(set(raw))):
        i_v[i] = v
        v_i[v] = i
    return v_i, i_v


xi, _ = compress_coord(X)
yj, _ = compress_coord(Y)
X = [xi[x] for x in X]
Y = [yj[y] for y in Y]
LL = {}
LR = {}
RL = {}
RR = {}
sty = SegmentTree([0] * N, lambda x, y: x + y, 0)
sortXY = sorted(zip(X, Y))
for x, y in sortXY:
    LL[(x, y)] = sty.query(0, y)
    LR[(x, y)] = sty.query(y, N)
    sty.update(y, 1)
sty = SegmentTree([0] * N, lambda x, y: x + y, 0)
for x, y in sortXY[::-1]:
    RL[(x, y)] = sty.query(0, y)
    RR[(x, y)] = sty.query(y, N)
    sty.update(y, 1)
ans = N * (pow(2, N, mod) - 1) % mod
for x, y in zip(X, Y):
    ll = LL[(x, y)]
    lr = LR[(x, y)]
    rl = RL[(x, y)]
    rr = RR[(x, y)]
    a = pow(2, ll + lr, mod) - 1
    b = pow(2, rl + rr, mod) - 1
    c = pow(2, ll + rl, mod) - 1
    d = pow(2, lr + rr, mod) - 1
    e = pow(2, ll, mod) - 1
    f = pow(2, lr, mod) - 1
    g = pow(2, rl, mod) - 1
    h = pow(2, rr, mod) - 1
    ans -= a + b + c + d
    ans += e + f + g + h
    ans %= mod
print(ans)


Fixed submission:
I = [int(_) for _ in open(0).read().split()]
N, X, Y = I[0], I[1::2], I[2::2]
mod = 998244353


def compress_coord(raw):
    #i_v = {}
    v_i = {}
    for i, v in enumerate(sorted(set(raw))):
        #i_v[i] = v
        v_i[v] = i
    return v_i  #, i_v


class BinaryIndexedTree():
    def __init__(self, n):
        """
        constructs binary indexed tree

        Parameters
        ----------
        n : int
            maximum index value
        """
        self.n = n
        self.dat = [0] * (n + 1)

    def sum(self, i):
        """
        returns the sum of [1, i]

        Parameters
        ----------
        i : int
            right end of the interval
        """
        s = 0
        while i:
            s += self.dat[i]
            i -= i & -i
        return s

    def add(self, i, x):
        """
        adds x to i-th element

        Parameters
        ----------
        i : int
            index
        x : int
            additional value
        """
        while i <= self.n:
            self.dat[i] += x
            i += i & -i


xi = compress_coord(X)
yj = compress_coord(Y)
X = [xi[x] for x in X]
Y = [yj[y] for y in Y]
LL = [0] * (2 * N)
LR = [0] * (2 * N)
RL = [0] * (2 * N)
RR = [0] * (2 * N)
sortXY = sorted(zip(X, Y))
bit = BinaryIndexedTree(N + 10)
for x, y in sortXY:
    LL[x] = bit.sum(y + 1)
    LR[x] = bit.sum(N + 1) - bit.sum(y + 1)
    bit.add(y + 1, 1)
bit = BinaryIndexedTree(N + 10)
for x, y in sortXY[::-1]:
    RL[x] = bit.sum(y + 1)
    RR[x] = bit.sum(N + 1) - bit.sum(y + 1)
    bit.add(y + 1, 1)
ans = N * (pow(2, N, mod) - 1) % mod
for ll, lr, rl, rr in zip(LL, LR, RL, RR):
    a = pow(2, ll + lr, mod)
    b = pow(2, rl + rr, mod)
    c = pow(2, ll + rl, mod)
    d = pow(2, lr + rr, mod)
    e = pow(2, ll, mod)
    f = pow(2, lr, mod)
    g = pow(2, rl, mod)
    h = pow(2, rr, mod)
    ans -= a + b + c + d
    ans += e + f + g + h
    ans %= mod
print(ans)