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). 
#include <bits/stdc++.h>
using namespace std;
template <class t, class u>
void mxz(t &a, u b) {
  if (a < b) a = b;
}
template <class t, class u>
void mnz(t &a, u b) {
  if (b < a) a = b;
}
void _scan(unsigned long long &x) { scanf("%llu", &x); }
void _scan(int &x) { scanf("%d", &x); }
void _scan(long long &x) { scanf("%lld", &x); }
void _scan(double &x) { scanf("%lf", &x); }
void _scan(char &x) { scanf(" %c", &x); }
void _scan(char *x) { scanf("%s", x); }
template <typename T>
void _scan(T &v) {
  for (auto &it : v) _scan(it);
}
void scan() {}
template <typename T, typename... U>
void scan(T &head, U &...tail) {
  _scan(head);
  scan(tail...);
}
void _print(long double x) { printf("%Lf", x); }
void _print(unsigned long long x) { printf("%llu", x); }
void _print(int x) { printf("%d", x); }
void _print(long long x) { printf("%lld", x); }
void _print(double x) { printf("%0.10lf", x); }
void _print(char x) { printf("%c", x); }
void _print(char *x) { printf("%s", x); }
void _print(string x) { printf("%s", x.c_str()); }
void _print(bool x) { printf("%s", (x) ? "YES" : "NO"); }
template <typename T, typename V>
void _print(const pair<T, V> &x) {
  _print(x.first);
  _print(' ');
  _print(x.second);
}
template <typename T>
void _print(const T &x) {
  int f = 0;
  for (auto &i : x) {
    if (f++) _print(' ');
    _print(i);
  }
}
void print() {}
template <typename T, typename... U>
void print(T head, U... tail) {
  _print(head);
  print(tail...);
}
inline long long flr(long long x, long long y);
inline long long cil(long long x, long long y) {
  assert(y != 0);
  if (y < 0LL) {
    y *= -1LL;
    x *= -1LL;
  }
  return (x < 0LL) ? -1 * flr(-1 * x, y) : (x + y - 1) / y;
}
inline long long flr(long long x, long long y) {
  assert(y != 0);
  if (y < 0LL) {
    y *= -1LL;
    x *= -1LL;
  }
  return (x < 0LL) ? -1 * cil(-1 * x, y) : x / y;
}
inline long long di(long long x, long long y) {
  assert(y != 0);
  assert(!(x % y));
  return x / y;
}
inline long long mod(long long x, long long y) {
  assert(y != 0);
  return x % y;
}
template <typename T>
inline void decr(T &x) {
  for (auto &it : x) it = it - 1;
}
void ___print(int x) { cerr << x; }
void ___print(long x) { cerr << x; }
void ___print(long long x) { cerr << x; }
void ___print(unsigned x) { cerr << x; }
void ___print(unsigned long x) { cerr << x; }
void ___print(unsigned long long x) { cerr << x; }
void ___print(float x) { cerr << x; }
void ___print(double x) { cerr << x; }
void ___print(long double x) { cerr << x; }
void ___print(char x) { cerr << '\'' << x << '\''; }
void ___print(const char *x) { cerr << '\"' << x << '\"'; }
void ___print(const string &x) { cerr << '\"' << x << '\"'; }
void ___print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void ___print(const pair<T, V> &x) {
  cerr << '{';
  ___print(x.first);
  cerr << ',';
  ___print(x.second);
  cerr << '}';
}
template <typename T>
void ___print(const T &x) {
  int f = 0;
  cerr << '{';
  for (auto &i : x) cerr << (f++ ? "," : ""), ___print(i);
  cerr << "}";
}
void __print() { cerr << "]\n"; }
template <typename T, typename... V>
void __print(T t, V... v) {
  ___print(t);
  if (sizeof...(v)) cerr << ", ";
  __print(v...);
}
vector<long long> a, b, c, d;
long long m, n, x, y, l, r;
long long sm = 0LL, mx = LONG_LONG_MIN, mn = LONG_LONG_MAX;
const long long MOD = 998244353;
template <typename T>
T Msum(T x) {
  return x;
}
template <typename T, typename... Rest>
T Msum(T x, Rest... rest) {
  return (x + Msum(rest...)) % MOD;
}
template <typename T>
T Mprod(T x) {
  return x;
}
template <typename T, typename... Rest>
T Mprod(T x, Rest... rest) {
  return x * Mprod(rest...) % MOD;
}
template <typename T>
T Mnorm(T x) {
  return (x % MOD + MOD) % MOD;
}
template <typename T>
T Msq(T x) {
  return (x * x) % MOD;
}
template <typename T>
T Mpot(T x, long long e) {
  if (!e) return 1;
  return Msq(Mpot(x, e >> 1)) * (e & 1 ? x : 1) % MOD;
}
template <typename T>
T Minv(T x) {
  return Mpot(x, MOD - 2);
}
vector<long long> f(400000, 0);
long long nck(long long n, long long k) {
  return Mprod(f[n], Minv(f[k]), Minv(f[n - k]));
}
void init() {
  iota(f.begin(), f.end(), 0);
  for (int i = 2; i < (int)400000; i++) f[i] = Mprod(f[i - 1], f[i]);
}
int main() {
  init();
  scan(n);
  (a).assign(2 * n, 0);
  scan(a);
  sort(a.begin(), a.end());
  long long sm = 0LL;
  for (int i = 0; i < (int)n; i++) {
    sm = Msum(sm, a[2 * n - i - 1] - a[i]);
  }
  print(Mprod(sm, nck(2 * n, n)), '\n');
  return 0;
}
