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.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class D {
    FastScanner scanner;
    PrintWriter writer;

    final long MOD = 998244353;

    void solve() throws IOException {
        scanner = new FastScanner(System.in);
        writer = new PrintWriter(System.out);

        int n = scanner.nextInt();

        int[] p = new int[n];
        for (int i = 0; i < n; i++) {
            p[i] = scanner.nextInt();
        }
        int[] q = new int[n];
        for (int i = 0; i < n; i++) {
            q[i] = scanner.nextInt();
        }

        Arrays.sort(p);
        Arrays.sort(q);

        long x = 0;
        for (int i = 0; i < n; i++) {
            x += Math.abs(p[i] - q[n - i - 1]);
        }

        long ans = x % MOD;
        for (int i = n + 1; i <= 2 * n; i++) {
            ans = (ans * i) % MOD;
        }

        for (int i = 1; i <= n; i++) {
            ans = (ans * pow(i, MOD - 2)) % MOD;
        }

        writer.println(ans);

        writer.close();
    }

    long pow(long a, long p) {
        if (p == 0)
            return 1;
        if (p % 2 == 1)
            return (pow(a, p - 1) * a) % MOD;
        else {
            long b = pow(a, p / 2);
            return (b * b) % MOD;
        }
    }

    public static void main(String[] args) throws IOException {
        new D().solve();
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer tokenizer;

        FastScanner(InputStream is) {
            this.br = new BufferedReader(new InputStreamReader(is));
        }

        FastScanner(File file) throws FileNotFoundException {
            this(new FileInputStream(file));
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        String next() throws IOException {
            while (tokenizer == null || !tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(br.readLine());

            return tokenizer.nextToken();
        }

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