### BUGGY 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)

    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)

if __name__ == '__main__':
    main()


### 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()