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). 
//package code;
import java.io.*;
import java.util.*; 
import java.math.*;

public class c 
{
    public static int t,Dx ,Dy ,J,n,len=1000005,answer,k,x,q,r,m,phi[],Bit[],mask ,a[],tin[],tout[],discover[],time=0, b[],degree[],parent[][] , size[] ,mat[][] , depth[],pre[],blockSize;
    static long  mod=(long)(1e9) + 7 ,sum ,mod1=(long)(998244353),bit[],ans , dp[][] , count[];
    static int[] dx={-1, 1,0,0} , dy={0 ,0 , -1 ,1};
    static int visited[],isPandatic[] ;
    public static TreeSet<Integer> ts[];
    public static ArrayList<Integer> list ,adj[] ,divisor[];
    public static PrintWriter pw;
    public static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    public static int max1=2000005;
    public static String[] s;
    public static void main(String[] args){
        new Thread(null,null,"Prabhat Kumar Prajapati",1<<28)
        {
           public void run() 
           {
               try
               {
                   solve();
               }
               catch(Exception e)
               {   
                   e.printStackTrace();
                   System.exit(1);
               }
           }
        }.start();
    }
// public static class Pair{
//         int ver;
//         long cost;
//         Pair(int ver , long cost){
//             this.ver=ver;
//             this.cost=cost;
//         }
//     }
public static class Point{
  int x,y;
  Point(int x ,int y){
    this.x=x;
    this.y=y;
  }
}
public static void solve()throws IOException
{
    pw = new PrintWriter(System.out);
    Scanner sc=new Scanner(System.in);
    n=sc.nextInt();
    a=new int[2*n];
    for(int i=0;i<2*n;i++)a[i]=sc.nextInt();
      Arrays.sort(a);
    long firstSum=0;
    long secondSum=0;
    for(int i=0;i<n;i++)firstSum+=a[i];
    for(int i=n;i<2*n;i++)secondSum+=a[i];
    pw.println((secondSum-firstSum+mod1)%mod1*nCk(2*n , n , mod1)%mod1);
    pw.close();
}

//(n-k+1)=(n-i) and i<k
// n*(n-1)*(n-2)*(n-3)...(n-k+1)
//-------------------------------
//k*(k-1)*(k-2)*(k-3).....1

public static long nCk(long n,long k,long mod){
  if(k>n-k)k = n-k;

  long res = 1;
  for(long i=0;i<k;i++){
        res = (res*(n-i))%mod1;
        res = res*(pow(i+1,mod1-2,mod1))%mod1;  // inverse 
            
    }
  return res;
}

static void dfs(int cur  , int temp){
  if(visited[cur]==0){
    visited[cur]=temp;
  }
  for(int ver:adj[cur]){
    if(visited[ver]==0){
      dfs(ver , temp);
    }
  }
}


  static long pascal(int i1,int j1)
  {
   long[][] pascal=new long[101][101];
    for(int i=0;i<=100;i++)
    {
      pascal[i][0]=1;
      for(int j=1;j<=i;j++)
      {
        pascal[i][j]=(pascal[i-1][j]+pascal[i-1][j-1])%mod;
      }
    }
    return pascal[i1][j1];
  }

static void update(int index , int val){
  while(index<len){
    Bit[index]=Math.max(Bit[index] ,val);
    index+=(index&(-index));
  }
}
static int query(int index){
  int max=0;
  while(index>0){
    max=Math.max(max  , Bit[index]);
    index-=(index&(-index));
  }
  return max;
}
// public static void dfs1(int cur , int par){
//   tin[cur]=time++;
//   parent[cur][0]=par==-1?0:par;
//   for(int i=1;i<28;i++)parent[cur][i]=parent[parent[cur][i-1]][i-1];

//   for(Pair p:adj[cur]){
//     int ver=p.ver;
//     if(ver==par)continue;
//     dfs1(ver,cur);
//   }
//   tout[cur]=time-1;
// }
public  static boolean isParent(int u ,int v){
  return tin[u]<=tin[v]&&tout[u]>=tout[v];
}
public  static int lca(int u , int v){
  if(isParent(u,v))return u;
  if(isParent(v,u))return v;

  for(int i=27;i>=0;i--){
    if(!isParent(parent[u][i],v)){
      u=parent[u][i];
    }
  }
  return parent[u][0];
}

static void phi(){
  phi=new int[len];
  boolean[] isPrime=new boolean[len];
  Arrays.fill(isPrime , true);
  for(int i=2;i<len;i++)phi[i]=i;

  for(int i=2;i<len;i++){
      if(phi[i] == i){
      phi[i] = i-1;
      for(int j = 2*i;j<len;j+=i)
        phi[j] = (phi[j]/i)*(i-1);
    }
  }
}
public static long[] seive(){
  // divisor = prime divisor
  //divisor=new LinkedList[len];
  long[] prefixSum=new long[len+1];
  //for(int i=0;i<len;i++)divisor[i]=new LinkedList<>();
    boolean[] isPrime=new boolean[len];
    Arrays.fill(isPrime , true);
    isPrime[0]=isPrime[1]=false;
    for(int i=2;i<len;i++){
      if(!isPrime[i]){
       prefixSum[i]=prefixSum[i-1];
       continue;
      }
      else prefixSum[i]=prefixSum[i-1]+i;

      for(int j=2*i;j<len;j+=i){
       // divisor[j].add(i);
        isPrime[j]=false;
      }
    }
    return prefixSum;
}


// here ans will store number of nodes on longest path
// static int dfs(int cur){
//     int d1=0;
//     int d2=0;
//     visited[cur]=true;
//     for(int ver:adj[cur]){
//         if(visited[ver])continue;
//         int x=dfs(ver);
//         if(x>d1){
//             d2=d1;
//             d1=x;
//         }
//         else if(x>d2){
//             d2=x;
//         }
//         ans=Math.max(ans , d1+d2+1);
//     }
//     //pw.println((cur+1)  +" "+d1+" "+d2);
//     return d1+1;
// }
public static long pow(long n,long p,long m)
{
    long  result = 1;
    while(p>0)
    {
        if(p%2==1)
            result =result * n %m;
        p >>=1;
        n=n*n % m;   
    }
    return result;
}

}
