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

/**
 * Created by Katushka on 11.03.2020.
 */
public class Main {

    static int[] readArray(int size, InputReader in) {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextInt();
        }
        return a;
    }

    static long[] readLongArray(int size, InputReader in) {
        long[] a = new long[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextLong();
        }
        return a;
    }

    static List<long[]> primeDivisors(long n) {
        long d = 2;
        List<long[]> res = new ArrayList<>();
        while (d * d <= n) {
            if (n % d == 0) {
                long[] p = {d, 1};
                res.add(p);
                while (n % d == 0) {
                    p[1] *= d;
                    n /= d;
                }
            } else {
                d += 1;
            }
        }
        if (n > 1) {
            res.add(new long[]{n, n});
        }
        return res;
    }

    private static long maxDivisor(long n) {
        long d = 2;
        long res = 1;
        while (d * d <= n) {
            if (n % d == 0) {
                res = Math.max(res, n / d);
                res = Math.max(res, d);
            }
            d += 1;
        }
        return res;
    }

    static long c(int n, int k, long mod, Map<Integer, Map<Integer, Long>> cache, Map<Long, Long> invs) {
        k = Math.min(k, n - k);

        if (cache != null && cache.containsKey(n) && cache.get(n).containsKey(k)) {
            return cache.get(n).get(k);
        }

        long nn = 1;
        for (long i = n - k + 1; i < n + 1; i++) {
            nn = nn * i % mod;
        }
        long kk = 1;
        for (int t = 1; t < k + 1; t++) {
            kk = kk * inv(t, mod, invs) % mod;
        }

        long result = nn * kk % mod;
        if (cache != null) {
            if (!cache.containsKey(n)) {
                cache.put(n, new HashMap<>());
            }
            cache.get(n).put(k, result);
        }
        return result;
    }

    private static long inv(long x, long mod, Map<Long, Long> cache) {
        if (cache != null) {
            if (!cache.containsKey(x)) {
                cache.put(x, fastPow(x, mod - 2, mod));
            }
            return cache.get(x);
        } else {
            return fastPow(x, mod - 2, mod);
        }
    }

    private static long fastPow(long x, long y, long mod) {
        if (x == 1) {
            return 1;
        }
        if (y == 0) {
            return 1;
        }
        long p = fastPow(x, y / 2, mod) % mod;
        p = p * p % mod;
        if (y % 2 == 1) {
            p = p * x % mod;
        }
        return p;
    }

    static void sortArray(long[] a) {
        Random random = new Random();

        for (int i = 0; i < a.length; i++) {
            int randomPos = random.nextInt(a.length);
            long t = a[i];
            a[i] = a[randomPos];
            a[randomPos] = t;
        }
        Arrays.sort(a);
    }

    private static final long MOD = 998244353;

    public static void main(String[] args) throws FileNotFoundException {
//        InputReader in = new InputReader(new FileInputStream("gangs.in"));
//        PrintWriter out = new PrintWriter(new BufferedOutputStream(new FileOutputStream("gangs.out")));

        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = in.nextInt();

        long[] a = readLongArray(2 * n, in);
        sortArray(a);
        long s1 = 0;
        long s2 = 0;
        for (int i = 0; i < n; i++) {
            s1 = (s1 + a[i]) % MOD;
            s2 = (s2 + a[n+i]) % MOD;
        }

        long ans = c(2 * n, n, MOD, null, null) * s2 % MOD;
        ans = (ans - c(2 * n, n, MOD, null, null) * s1 % MOD + MOD) % MOD;
        out.println(ans);

        out.close();
    }

    private static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                createTokenizer();
            }
            return tokenizer.nextToken();
        }

        private void createTokenizer() {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public String nextWord() {
            return next();
        }

        public String nextString() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

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

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

        public char nextChar() {
            return next().charAt(0);
        }

        public int[] nextInts() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                createTokenizer();
            }
            List<Integer> res = new ArrayList<>();
            while (tokenizer.hasMoreElements()) {
                res.add(Integer.parseInt(tokenizer.nextToken()));
            }
            int[] resArray = new int[res.size()];
            for (int i = 0; i < res.size(); i++) {
                resArray[i] = res.get(i);
            }
            return resArray;
        }
    }
}