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.*;
public class D {
  void solve() {
    int n = nextInt();
    List<Integer> p = new ArrayList<>();
    List<Integer> q = new ArrayList<>();
    for (int i = 0; i<n; i++) {
      p.add(nextInt());
      q.add(nextInt());
    }
    Collections.sort(p);
    Collections.sort(q, Collections.reverseOrder());
    long sum = 0;
    for (int i = 0; i<n; i++) {
      long a = p.get(i);
      long b = q.get(i);
      if (a>=b) {
        sum=add(sum, a-b);
      } else {
        sum=add(sum, b-a);
      }
    }
    long fact1 = 1;
    for (int i = 2*n; i>n; i--) {
      fact1=mul(fact1, i);
    }
    long fact2 = 1;
    for (int i = n; i>1; i--) {
      fact2=mul(fact2, i);
    }
    long combinations = div(fact1, fact2);
    long ans = mul(sum, combinations);
    out.println(ans);
  }
  private static int mod = 998244353;
  public static long add(long a, long b) {
    long answer = a+b;
    return answer>=mod ? answer-mod : answer;
  }
  public static long sub(long a, long b) {
    long answer = a-b;
    return answer<0 ? answer+mod : answer;
  }
  public static long mul(long a, long b) {
    long answer = a*b;
    return answer>=mod ? answer%mod : answer;
  }
  public static long div(long a, long b) {
    long inv_b = pow(b, mod-2);
    return mul(a, inv_b);
  }
  public static long pow(long a, long b) {
    long result = 1;
    while (b>0) {
      if (b%2==1)
        result=mul(result, a);
      a=mul(a, a);
      b=b/2;
    }
    return result;
  }
  static int nextInt() {
    return Integer.parseInt(nextToken());
  }
  static String nextToken() {
    while (!st.hasMoreTokens()) {
      try {
        st=new StringTokenizer(br.readLine());
      } catch (Exception e) {
        throw new RuntimeException("out of tokens!");
      }
    }
    return st.nextToken();
  }
  static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  static StringTokenizer st = new StringTokenizer("");
  static PrintWriter out = new PrintWriter(System.out);
  public static void main(String[] a) {
    new D().solve();
    out.flush();
  }
}
