

import sys

input = sys.stdin.readline





class SegmentTree:

    def __init__(self, L, op, default_val):

        self.op = op

        self.default_val = default_val

        self.sz = len(L)

        self.n = 1

        self.s = 1

        for i in range(1000):

            self.n *= 2

            self.s += 1

            if self.n >= self.sz:

                break

        self.node = [self.default_val]*(2*self.n-1)



        for i in range(self.sz):

            self.node[i+self.n-1] = L[i]



        for i in range(self.n-2,-1,-1):

            self.node[i] = self.op(self.node[i*2+1],self.node[i*2+2])

    

    def add(self, a, x):

        k = a+self.n-1

        self.node[k] += x

        for i in range(1000):

            k = (k-1)//2

            self.node[k] = self.op(self.node[2*k+1], self.node[2*k+2])

            if k <= 0:

                break

    

    def get(self, l, r):

        res = self.default_val

        n = self.n

        if self.sz <= r or 0 > l:

            print("ERROR: the indice are wrong.")

            return False



        for i in range(self.s):

            count = 2**i-1

            a = (r+1)//n

            b = (l-1)//n

            if a-b == 3:

                res = self.op(self.node[count+b+1],res)

                res = self.op(self.node[count+b+2],res)

                right = a*n

                left = (b+1)*n-1

                break

            if a-b == 2:

                res = self.op(self.node[count+b+1],res)

                right = a*n

                left = (b+1)*n-1

                break

            n = n//2



        n1 = n//2        

        #left

        for j in range(i+1,self.s):

            count = 2**j-1 

            a = (left+1)//n1

            b = (l-1)//n1

            if a-b == 2:

                res = self.op(self.node[count+b+1],res)

                left = (b+1)*n1-1                

            n1 = n1//2



        n1 = n//2        

        #right

        for j in range(i+1,self.s):

            count = 2**j-1 

            a = (r+1)//n1

            b = (right-1)//n1

            if a-b == 2:

                res = self.op(self.node[count+b+1],res)

                right = a*n1                

            n1 = n1//2

        return res



N = int(eval(input()))

point = [list(map(int,input().split())) for i in range(N)]



point.sort(lambda x: x[1])

for i in range(len(point)):

    point[i][1] = i



mod = 998244353



ans = ((N-4)*pow(2,N,mod)+3*N+4)%mod



pow2 = []

a = 1

for i in range(N+1):

    pow2.append(a)

    a *= 2

    a %= mod



point.sort(lambda x: x[0])



ST = SegmentTree([0]*len(point), lambda a,b:a+b, 0)





for i,(x,y) in enumerate(point):

    if point[i][1] > 0:

        ld = ST.get(0,y-1)

        #ls = i//2

    else:

        ld = 0

    lu = i-ld

    rd = y - ld

    ru = N - i - 1 - rd    

    ans += pow2[lu]-1

    ans += pow2[ld]-1

    ans += pow2[ru]-1

    ans += pow2[rd]-1

    ans %= mod

    ST.add(point[i][1],1)



print(ans)


import sys

input = sys.stdin.readline

 



class BIT:

            

    def __init__(self, L):

        self.N = len(L)

        self.bit = [0]*self.N

        for i,l in enumerate(L):

            self.add(i,l)



    def add(self, a, w):

        x = a + 1

        for i in range(1000):

            self.bit[x-1] += w

            x += x & -x

            if x > self.N:

                break



    def sum(self, a):

        x = a+1

        ret = 0

        for i in range(1000):

            ret += self.bit[x-1]

            x -= x & -x

            if x <= 0:

                break        

        return ret



 

N = int(eval(input()))

point = [list(map(int,input().split())) for i in range(N)]

 

point.sort(lambda x: x[1])

for i in range(len(point)):

    point[i][1] = i

 

mod = 998244353

 

ans = ((N-4)*pow(2,N,mod)+3*N+4)%mod

 

pow2 = []

a = 1

for i in range(N+1):

    pow2.append(a)

    a *= 2

    a %= mod

 

point.sort(lambda x: x[0])

 

bit = BIT([0]*len(point))

 

 

for i,(x,y) in enumerate(point):

    if y > 0:

        ld = bit.sum(y-1)

        #ls = i//2

    else:

        ld = 0

    lu = i-ld

    rd = y - ld

    ru = N - i - 1 - rd    

    ans += pow2[lu]-1

    ans += pow2[ld]-1

    ans += pow2[ru]-1

    ans += pow2[rd]-1

    ans %= mod

    bit.add(y,1)

 

print(ans)
import sys

input = sys.stdin.readline


class SegmentTree:
    def __init__(self, L, op, default_val):
        self.op = op
        self.default_val = default_val
        self.sz = len(L)
        self.n = 1
        self.s = 1
        for i in range(1000):
            self.n *= 2
            self.s += 1
            if self.n >= self.sz:
                break
        self.node = [self.default_val] * (2 * self.n - 1)
        for i in range(self.sz):
            self.node[i + self.n - 1] = L[i]
        for i in range(self.n - 2, -1, -1):
            self.node[i] = self.op(self.node[i * 2 + 1], self.node[i * 2 + 2])

    def add(self, a, x):
        k = a + self.n - 1
        self.node[k] += x
        for i in range(1000):
            k = (k - 1) // 2
            self.node[k] = self.op(self.node[2 * k + 1], self.node[2 * k + 2])
            if k <= 0:
                break

    def get(self, l, r):
        res = self.default_val
        n = self.n
        if self.sz <= r or 0 > l:
            print("ERROR: the indice are wrong.")
            return False
        for i in range(self.s):
            count = 2**i - 1
            a = (r + 1) // n
            b = (l - 1) // n
            if a - b == 3:
                res = self.op(self.node[count + b + 1], res)
                res = self.op(self.node[count + b + 2], res)
                right = a * n
                left = (b + 1) * n - 1
                break
            if a - b == 2:
                res = self.op(self.node[count + b + 1], res)
                right = a * n
                left = (b + 1) * n - 1
                break
            n = n // 2
        n1 = n // 2
        # left
        for j in range(i + 1, self.s):
            count = 2**j - 1
            a = (left + 1) // n1
            b = (l - 1) // n1
            if a - b == 2:
                res = self.op(self.node[count + b + 1], res)
                left = (b + 1) * n1 - 1
            n1 = n1 // 2
        n1 = n // 2
        # right
        for j in range(i + 1, self.s):
            count = 2**j - 1
            a = (r + 1) // n1
            b = (right - 1) // n1
            if a - b == 2:
                res = self.op(self.node[count + b + 1], res)
                right = a * n1
            n1 = n1 // 2
        return res


N = int(eval(input()))
point = [list(map(int, input().split())) for i in range(N)]
point.sort(lambda x: x[1])
for i in range(len(point)):
    point[i][1] = i
mod = 998244353
ans = ((N - 4) * pow(2, N, mod) + 3 * N + 4) % mod
pow2 = []
a = 1
for i in range(N + 1):
    pow2.append(a)
    a *= 2
    a %= mod
point.sort(lambda x: x[0])
ST = SegmentTree([0] * len(point), lambda a, b: a + b, 0)
for i, (x, y) in enumerate(point):
    if point[i][1] > 0:
        ld = ST.get(0, y - 1)
        # ls = i//2
    else:
        ld = 0
    lu = i - ld
    rd = y - ld
    ru = N - i - 1 - rd
    ans += pow2[lu] - 1
    ans += pow2[ld] - 1
    ans += pow2[ru] - 1
    ans += pow2[rd] - 1
    ans %= mod
    ST.add(point[i][1], 1)
print(ans)

import sys

input = sys.stdin.readline


class BIT:
    def __init__(self, L):
        self.N = len(L)
        self.bit = [0] * self.N
        for i, l in enumerate(L):
            self.add(i, l)

    def add(self, a, w):
        x = a + 1
        for i in range(1000):
            self.bit[x - 1] += w
            x += x & -x
            if x > self.N:
                break

    def sum(self, a):
        x = a + 1
        ret = 0
        for i in range(1000):
            ret += self.bit[x - 1]
            x -= x & -x
            if x <= 0:
                break
        return ret


N = int(eval(input()))
point = [list(map(int, input().split())) for i in range(N)]
point.sort(lambda x: x[1])
for i in range(len(point)):
    point[i][1] = i
mod = 998244353
ans = ((N - 4) * pow(2, N, mod) + 3 * N + 4) % mod
pow2 = []
a = 1
for i in range(N + 1):
    pow2.append(a)
    a *= 2
    a %= mod
point.sort(lambda x: x[0])
bit = BIT([0] * len(point))
for i, (x, y) in enumerate(point):
    if y > 0:
        ld = bit.sum(y - 1)
        # ls = i//2
    else:
        ld = 0
    lu = i - ld
    rd = y - ld
    ru = N - i - 1 - rd
    ans += pow2[lu] - 1
    ans += pow2[ld] - 1
    ans += pow2[ru] - 1
    ans += pow2[rd] - 1
    ans %= mod
    bit.add(y, 1)
print(ans)

-class SegmentTree: -    def __init__(self, L, op, default_val): -        self.op = op -        self.default_val = default_val -        self.sz = len(L) -        self.n = 1 -        self.s = 1 +class BIT: +    def __init__(self, L): +        self.N = len(L) +        self.bit = [0] * self.N +        for i, l in enumerate(L): +            self.add(i, l) + +    def add(self, a, w): +        x = a + 1 -            self.n *= 2 -            self.s += 1 -            if self.n >= self.sz: -                break -        self.node = [self.default_val] * (2 * self.n - 1) -        for i in range(self.sz): -            self.node[i + self.n - 1] = L[i] -        for i in range(self.n - 2, -1, -1): -            self.node[i] = self.op(self.node[i * 2 + 1], self.node[i * 2 + 2]) - -    def add(self, a, x): -        k = a + self.n - 1 -        self.node[k] += x -        for i in range(1000): -            k = (k - 1) // 2 -            self.node[k] = self.op(self.node[2 * k + 1], self.node[2 * k + 2]) -            if k <= 0: +            self.bit[x - 1] += w +            x += x & -x +            if x > self.N: -    def get(self, l, r): -        res = self.default_val -        n = self.n -        if self.sz <= r or 0 > l: -            print("ERROR: the indice are wrong.") -            return False -        for i in range(self.s): -            count = 2**i - 1 -            a = (r + 1) // n -            b = (l - 1) // n -            if a - b == 3: -                res = self.op(self.node[count + b + 1], res) -                res = self.op(self.node[count + b + 2], res) -                right = a * n -                left = (b + 1) * n - 1 +    def sum(self, a): +        x = a + 1 +        ret = 0 +        for i in range(1000): +            ret += self.bit[x - 1] +            x -= x & -x +            if x <= 0: -            if a - b == 2: -                res = self.op(self.node[count + b + 1], res) -                right = a * n -                left = (b + 1) * n - 1 -                break -            n = n // 2 -        n1 = n // 2 -        # left -        for j in range(i + 1, self.s): -            count = 2**j - 1 -            a = (left + 1) // n1 -            b = (l - 1) // n1 -            if a - b == 2: -                res = self.op(self.node[count + b + 1], res) -                left = (b + 1) * n1 - 1 -            n1 = n1 // 2 -        n1 = n // 2 -        # right -        for j in range(i + 1, self.s): -            count = 2**j - 1 -            a = (r + 1) // n1 -            b = (right - 1) // n1 -            if a - b == 2: -                res = self.op(self.node[count + b + 1], res) -                right = a * n1 -            n1 = n1 // 2 -        return res +        return ret -ST = SegmentTree([0] * len(point), lambda a, b: a + b, 0) +bit = BIT([0] * len(point)) -    if point[i][1] > 0: -        ld = ST.get(0, y - 1) +    if y > 0: +        ld = bit.sum(y - 1) -    ST.add(point[i][1], 1) +    bit.add(y, 1)