You are given an array a of length 2n. Consider a partition of array a into two subsequences p and q of length n each (each element of array a should be in exactly one subsequence: either in p or in q).

Let's sort p in non-decreasing order, and q in non-increasing order, we can denote the sorted versions by x and y, respectively. Then the cost of a partition is defined as f(p, q) = ∑_{i = 1}^n |x_i - y_i|.

Find the sum of f(p, q) over all correct partitions of array a. Since the answer might be too big, print its remainder modulo 998244353.

Input

The first line contains a single integer n (1 ≤ n ≤ 150 000).

The second line contains 2n integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^9) — elements of array a.

Output

Print one integer — the answer to the problem, modulo 998244353.

Examples

Input


1
1 4


Output


6

Input


2
2 1 2 1


Output


12

Input


3
2 2 2 2 2 2


Output


0

Input


5
13 8 35 94 9284 34 54 69 123 846


Output


2588544

Note

Two partitions of an array are considered different if the sets of indices of elements included in the subsequence p are different.

In the first example, there are two correct partitions of the array a:

  1. p = [1], q = [4], then x = [1], y = [4], f(p, q) = |1 - 4| = 3; 
  2. p = [4], q = [1], then x = [4], y = [1], f(p, q) = |4 - 1| = 3. 



In the second example, there are six valid partitions of the array a: 

  1. p = [2, 1], q = [2, 1] (elements with indices 1 and 2 in the original array are selected in the subsequence p); 
  2. p = [2, 2], q = [1, 1]; 
  3. p = [2, 1], q = [1, 2] (elements with indices 1 and 4 are selected in the subsequence p); 
  4. p = [1, 2], q = [2, 1]; 
  5. p = [1, 1], q = [2, 2]; 
  6. p = [2, 1], q = [2, 1] (elements with indices 3 and 4 are selected in the subsequence p). 
import io
import os

from collections import Counter, defaultdict, deque


MOD = 998244353

MAX_N = 3 * 10 ** 5 + 1


def modInverse(a, p):
    return pow(a, p - 2, p)


# Precompute all factorials: i!
fact = [1]
for i in range(1, MAX_N + 1):
    fact.append((fact[-1] * i) % MOD)

# Precompute all inverse factorials: 1 / (i!)
invFact = [0] * (MAX_N + 1)
invFact[MAX_N] = modInverse(fact[MAX_N], MOD)
for i in range(MAX_N - 1, -1, -1):
    invFact[i] = (invFact[i + 1] * (i + 1)) % MOD
    # assert fact[i] * invFact[i] % MOD == 1

# Precompute all inverses, 1 / i == (i - 1)! / i!
inv = [0] * (MAX_N + 1)
for i in range(1, MAX_N + 1):
    inv[i] = fact[i - 1] * invFact[i] % MOD
    # assert inv[i] * i % MOD == 1


def nCr(n, r):  # mod'd
    if n < r:
        return 0
    return (fact[n] * invFact[r] * invFact[n - r]) % MOD


def solve1(N, A):
    A.sort()
    score = 0
    # freq = Counter()
    for mask in range(2 ** (2 * N)):
        P = []
        Q = []
        for i in range(2 * N):
            if (1 << i) & mask:
                P.append(i)
            else:
                Q.append(i)
        if len(P) == len(Q) == N:
            P.sort(key=lambda i: A[i])
            Q.sort(key=lambda i: A[i], reverse=True)
            # for i, j in zip(P, Q):
            #    freq[(i, j)] += 1
            score += sum(abs(A[i] - A[j]) for i, j in zip(P, Q))
    return score % MOD


def solve(N, A):
    A.sort()
    return (nCr(2 * N, N) * (sum(A[N:]) - sum(A[:N]))) % MOD


DEBUG = False
if DEBUG:
    import random

    random.seed(0)
    for _ in range(100):
        N = random.randint(1, 10)
        A = [random.randint(1, 10) for i in range(2 * N)]
        print("tc", _, N, A)
        ans1 = solve1(N, A)
        ans = solve(N, A)
        assert ans1 == ans
        print(ans1, ans)
    exit()

if __name__ == "__main__":
    input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

    TC = 1
    for tc in range(1, TC + 1):
        (N,) = [int(x) for x in input().split()]
        A = [int(x) for x in input().split()]
        ans = solve(N, A)
        print(ans)
