### BUGGY CODE ###

import sys
import io, os
input = sys.stdin.buffer.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

n = int(input())
mod = 998244353
XY = []
X = set()
Y = set()
for i in range(n):
    x,y = map(int, input().split())
    XY.append((x, y))
    X.add(x)
    Y.add(y)

X = list(X)
Y = list(Y)
X.sort()
Y.sort()
dx = {}
for i, x in enumerate(X):
    dx[x] = i
dy = {}
for i, y in enumerate(Y):
    dy[y] = i

XY.sort()
XY = [(dx[x], dy[y]) for x, y in XY]

class BIT:
    def __init__(self, n):
        self.n = n
        self.bit = [0]*(self.n+1) # 1-indexed

    def init(self, init_val):
        for i, v in enumerate(init_val):
            self.add(i, v)

    def add(self, i, x):
        # i: 0-indexed
        i += 1 # to 1-indexed
        while i <= self.n:
            self.bit[i] += x
            i += (i & -i)

    def sum(self, i, j):
        # return sum of [i, j)
        # i, j: 0-indexed
        return self._sum(j) - self._sum(i)

    def _sum(self, i):
        # return sum of [0, i)
        # i: 0-indexed
        res = 0
        while i > 0:
            res += self.bit[i]
            i -= i & (-i)
        return res

    def lower_bound(self, x):
        s = 0
        pos = 0
        depth = self.n.bit_length()
        v = 1 << depth
        for i in range(depth, -1, -1):
            k = pos + v
            if k <= self.n and s + self.bit[k] < x:
                    s += self.bit[k]
                    pos += v
            v >>= 1
        return pos

UL = [0]*n
UR = [0]*n
LL = [0]*n
LR = [0]*n

bit = BIT(2*10**5+5)
for i in range(n):
    x, y = XY[i]
    LL[i] = bit.sum(0, y+1)
    UL[i] = i-LL[i]
    bit.add(y, 1)

bit = BIT(2*10**5+5)
for i in reversed(range(n)):
    x, y = XY[i]
    LR[i] = bit.sum(0, y+1)
    UR[i] = (n-1-i)-LR[i]
    bit.add(y, 1)

#print(LL)
#print(UL)
#print(LR)
#print(UR)

def power(a, n, mod):
    bi=str(format(n,"b")) #2進数
    res=1
    for i in range(len(bi)):
        res=(res*res) %mod
        if bi[i]=="1":
            res=(res*a) %mod
    return res

ans = 0
for i in range(n):
    ans += (power(2, UL[i], mod)-1)*(power(2, LR[i], mod)-1)*power(2, UR[i], mod)*power(2, LL[i], mod)
    ans += power(2, UL[i], mod)*power(2, LR[i], mod)*(power(2, UR[i], mod)-1)*(power(2, LL[i], mod)-1)
    ans -= (power(2, UL[i], mod)-1)*(power(2, LR[i], mod)-1)*(power(2, UR[i], mod)-1)*(power(2, LL[i], mod)-1)
    ans += power(2, UL[i], mod)*power(2, LR[i], mod)*power(2, UR[i], mod)*power(2, LL[i], mod)
ans %= mod
print(ans)


### FIXED CODE ###

import sys
import io, os
#input = sys.stdin.buffer.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

mod = 998244353

def main():
    n = int(input())
    XY = []
    X = set()
    Y = set()
    for i in range(n):
        x,y = map(int, input().split())
        XY.append((x, y))
        X.add(x)
        Y.add(y)

    X = list(X)
    Y = list(Y)
    X.sort()
    Y.sort()
    dx = {}
    for i, x in enumerate(X):
        dx[x] = i
    dy = {}
    for i, y in enumerate(Y):
        dy[y] = i

    XY.sort()
    XY = [(dx[x], dy[y]) for x, y in XY]

    class BIT:
        def __init__(self, n):
            self.n = n
            self.bit = [0]*(self.n+1) # 1-indexed

        def init(self, init_val):
            for i, v in enumerate(init_val):
                self.add(i, v)

        def add(self, i, x):
            # i: 0-indexed
            i += 1 # to 1-indexed
            while i <= self.n:
                self.bit[i] += x
                i += (i & -i)

        def sum(self, i, j):
            # return sum of [i, j)
            # i, j: 0-indexed
            return self._sum(j) - self._sum(i)

        def _sum(self, i):
            # return sum of [0, i)
            # i: 0-indexed
            res = 0
            while i > 0:
                res += self.bit[i]
                i -= i & (-i)
            return res

        def lower_bound(self, x):
            s = 0
            pos = 0
            depth = self.n.bit_length()
            v = 1 << depth
            for i in range(depth, -1, -1):
                k = pos + v
                if k <= self.n and s + self.bit[k] < x:
                        s += self.bit[k]
                        pos += v
                v >>= 1
            return pos

    UL = [0]*n
    UR = [0]*n
    LL = [0]*n
    LR = [0]*n

    bit = BIT(2*10**5+5)
    for i in range(n):
        x, y = XY[i]
        LL[i] = bit.sum(0, y+1)
        UL[i] = i-LL[i]
        bit.add(y, 1)

    bit = BIT(2*10**5+5)
    for i in reversed(range(n)):
        x, y = XY[i]
        LR[i] = bit.sum(0, y+1)
        UR[i] = (n-1-i)-LR[i]
        bit.add(y, 1)

    #print(LL)
    #print(UL)
    #print(LR)
    #print(UR)

    ans = 0
    for i in range(n):
        ans += (pow(2, UL[i], mod)-1)*(pow(2, LR[i], mod)-1)*pow(2, UR[i], mod)*pow(2, LL[i], mod)
        ans += pow(2, UL[i], mod)*pow(2, LR[i], mod)*(pow(2, UR[i], mod)-1)*(pow(2, LL[i], mod)-1)
        ans -= (pow(2, UL[i], mod)-1)*(pow(2, LR[i], mod)-1)*(pow(2, UR[i], mod)-1)*(pow(2, LL[i], mod)-1)
        ans += pow(2, UL[i], mod)*pow(2, LR[i], mod)*pow(2, UR[i], mod)*pow(2, LL[i], mod)
        ans %= mod
    print(ans)

if __name__ == '__main__':
    main()