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 CFA {
  BufferedReader br;
  PrintWriter out;
  StringTokenizer st;
  boolean eof;
//  private static final long MOD = 1000L * 1000L * 1000L + 7;
  private static final long MOD = 998244353L;
  private static final int[] dx = {0, -1, 0, 1};
  private static final int[] dy = {1, 0, -1, 0};
  private static final String yes = "Yes";
  private static final String no = "No";

  void solve() {
//    int T = nextInt();
    int T = 1;
    for (int i = 0; i < T; i++) {
      helper();
    }
  }

  long[] fact;
  long[] invfact;
  int LIMIT = 1000 * 1000 + 10;
  void helper() {
    int n = nextInt();
    long[] arr = nextLongArr(2 * n);
    shuffle(arr);
    Arrays.sort(arr);
    long diff = 0;
    for (int i = 0; i < n; i++) {
      diff += arr[i + n];
      diff -= arr[i];
    }
    diff %= MOD;

    // another way to caculate inv factorial
    fact = new long[LIMIT];
    invfact = new long[LIMIT];
    fact[0] = 1;
    for (int i = 1; i < LIMIT; i++) {
      fact[i] = fact[i - 1] * i % MOD;
    }

    invfact[LIMIT - 1] = powMod(fact[LIMIT - 1], MOD - 2, MOD);
    for (int i = LIMIT - 2; i >= 0; i--) {
      invfact[i] = invfact[i + 1] * (i + 1) % MOD;
    }

    diff = diff * comb(2 * n, n) % MOD;
    outln(diff);
  }

  // Power Calculate N^M % MOD, N and M can be long (up to 2^64, ~10^18)
  public long powMod(long N, long M, long MOD){//N^M % MOD
    if(M == 0L)
      return 1L;
    long[] hp = new long[64];
    boolean[] bp = new boolean[64];
    hp[0] = N;
    for(int i = 1; i < hp.length; i++) {
      hp[i] = (hp[i - 1] * hp[i - 1]) % MOD;
    }
    for(int j = 0; j < hp.length; j++) {
      if((M & (1L << j)) != 0)
        bp[j] = true;
    }
    long res = 1;
    for(int i = 0;i < bp.length; i++){
      if(bp[i]) {
        res = (res * hp[i]) % MOD;
      }
    }
    return res;
  }

  long comb(int n, int r) {
    long res = fact[n] * invfact[r] % MOD;
    res = res * invfact[n - r] % MOD;
    return res;
  }

  void shuffle(long[] a) {
    int n = a.length;
    for(int i = 0; i < n; i++) {
      int r = i + (int) (Math.random() * (n - i));
      long tmp = a[i];
      a[i] = a[r];
      a[r] = tmp;
    }
  }

  int gcd(int a, int b) {
    while(a != 0 && b != 0) {
      int c = b;
      b = a % b;
      a = c;
    }
    return a + b;
  }
  private void outln(Object o) {
    out.println(o);
  }
  private void out(Object o) {
    out.print(o);
  }
  private void formatPrint(double val) {
    outln(String.format("%.9f%n", val));
  }
  public CFA() {
    br = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);
    solve();
    out.close();
  }
  public static void main(String[] args) {
    new CFA();
  }

  public long[] nextLongArr(int n) {
    long[] res = new long[n];
    for(int i = 0; i < n; i++)
      res[i] = nextLong();
    return res;
  }
  public int[] nextIntArr(int n) {
    int[] res = new int[n];
    for(int i = 0; i < n; i++)
      res[i] = nextInt();
    return res;
  }
  public String nextToken() {
    while (st == null || !st.hasMoreTokens()) {
      try {
        st = new StringTokenizer(br.readLine());
      } catch (Exception e) {
        eof = true;
        return null;
      }
    }
    return st.nextToken();
  }
  public String nextString() {
    try {
      return br.readLine();
    } catch (IOException e) {
      eof = true;
      return null;
    }
  }
  public int nextInt() {
    return Integer.parseInt(nextToken());
  }
  public long nextLong() {
    return Long.parseLong(nextToken());
  }
  public double nextDouble() {
    return Double.parseDouble(nextToken());
  }
}
