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 java.util.*;
import java.io.*;

public class B1444 {

	static int[] a;
	static int n;
//	static long[] cnt;
	static final int mod = 998244353;
//	static long[][][] dp;

//	public static long[] dp(int idx, int x, int y) {
//
//		if (dp[x][y] != null) {
//			return dp[x][y];
//		}
//		long[] ans = new long[2];
//		if (x == n && y == n) {
//			return dp[x][y] = new long[] { 0, 1 };
//		}
//		if (x < n) {
//			long[] l = dp(idx + 1, x + 1, y);
////					+ a[idx] * (x + y >= n ? 1 : -1);
//			ans[1] += l[1];
//			ans[0] += l[0];
//		}
//		if (y < n) {
//			long[] l = dp(idx + 1, x, y + 1);
//			ans[1] += l[1];
//			ans[0] += l[0];
////			ans += dp(idx + 1, x, y + 1) + a[idx] * (x + y >= n ? 1 : -1);
//		}
//		ans[0] += a[idx] * (x + y >= n ? 1 : -1) * ans[1];
//		return dp[x][y] = ans;
//	}

//	public static long nck(int n, int k) {
//		long ans = 1;
//		for (int i = 1; i <= k; i++) {
//			ans *= n - i + 1;
//			ans /= i;
//		}
//		return ans;
//	}

	public static long modPow(long a, long e) {
		long res = 1;
		while (e > 0) {
			if ((e & 1) != 0) {
				res = res * a % mod;
			}
			e >>= 1;
			a = a * a % mod;
		}
		return res;
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		n = sc.nextInt();
		a = sc.nextIntArr(2 * n);
		Arrays.sort(a);
//		dp = new long[n + 1][n + 1][];
//
//		pw.println(dp(0, 0, 0)[0]);
//		for (int i = 0; i <= n; i++) {
//			for (int j = 0; j <= n; j++) {
//				pw.printf("%03d ", dp[i][j][1]);
//			}
//			pw.println();
//		}
		long[] fac = new long[2 * n + 1];
		long[] invFac = new long[2 * n + 1];
		fac[0] = invFac[0] = 1;
		for (int i = 1; i < fac.length; i++) {
			fac[i] = (i * fac[i - 1]) % mod;
			invFac[i] = (modPow(i, mod - 2) * invFac[i - 1]) % mod;
		}
		long ans = 0;
		long nck = fac[2 * n] * invFac[n] % mod * invFac[n] % mod;
		for (int i = 0; i < 2 * n; i++) {
			ans += a[i] * (i >= n ? 1 : -1);
			ans %= mod;
		}
		
		ans *= nck;
//		pw.println(Arrays.deepToString(dp));
		pw.println(ans % mod);
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader f) {
			br = new BufferedReader(f);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public int[] nextIntArr(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = Integer.parseInt(next());
			}
			return arr;
		}

	}

}
