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). 
# -*- coding: utf-8 -*-
import sys, string
from collections import deque, defaultdict
from math import sqrt, factorial, gcd, ceil, atan, pi, log2
# def input(): return sys.stdin.readline()[:-1] # warning not \n
# def input(): return sys.stdin.buffer.readline().strip() # warning bytes
def input(): return sys.stdin.buffer.readline().decode('utf-8')
# string.ascii_lowercase
from bisect import bisect_left, bisect_right
from operator import add
MOD = int(1e9)+7
INF = float('inf')

# sys.setrecursionlimit(int(1e6))

MOD = 998244353

def prod(a, b):
    ans = 1
    for x in range(a, b + 1):
        ans *= x
        ans %= MOD
    return ans

def fact(x):
    ans = 1
    while x:
        ans *= x
        ans %= MOD
        x -= 1
    return ans

def coef(n, k):
    if k > n: return 0
    return (prod(n - k + 1, n) * pow(fact(k)%MOD, MOD - 2, MOD)) % MOD


def solve():
    n = int(input())
    a = [int(x) for x in input().split()]
    a.sort()
    a, b = a[:n], a[n:]
    b = b[::-1]

    print((sum([abs(b[i] - a[i]) for i in range(n)]) * coef(n*2, n))%MOD)




T = 1
# T = int(input())
for case in range(1,T+1):
    # try:
        ans = solve()
    # except:
    #     import traceback
    #     print(traceback.format_exc())

"""

3 2

3 1







"""

