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>
namespace IO {
char ibuf[1 << 21], *p1 = ibuf, *p2 = ibuf, obuf[1 << 21], *p = obuf;
struct outflush {
  ~outflush() {
    (void)(fwrite(::IO::obuf, 1, ::IO::p - ::IO::obuf, stdout), fflush(stdout),
           ::IO::p = ::IO::obuf);
  }
} flushout;
}  // namespace IO
int rec() {
  int ch;
  while (isspace(ch = (::IO::p1 == ::IO::p2 &&
                               (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                           fread(::IO::ibuf, 1, 1 << 21, stdin),
                                ::IO::p1 == ::IO::p2)
                           ? EOF
                           : *::IO::p1++)))
    ;
  return ch;
}
bool rei(char& c) {
  int ch;
  while (isspace(ch = (::IO::p1 == ::IO::p2 &&
                               (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                           fread(::IO::ibuf, 1, 1 << 21, stdin),
                                ::IO::p1 == ::IO::p2)
                           ? EOF
                           : *::IO::p1++)))
    ;
  if (ch == EOF) return false;
  c = ch;
  return true;
}
bool rei(char* s) {
  if (!rei(*s)) return false;
  int ch;
  while (*++s = ch = (::IO::p1 == ::IO::p2 &&
                              (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                          fread(::IO::ibuf, 1, 1 << 21, stdin),
                               ::IO::p1 == ::IO::p2)
                          ? EOF
                          : *::IO::p1++),
         ch != EOF && !isspace(ch))
    ;
  *s = 0;
  return true;
}
template <class T>
bool rei(T& x) {
  bool f = true;
  int ch;
  for (ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++);
       !isdigit(ch);
       ch = (::IO::p1 == ::IO::p2 &&
                     (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                 fread(::IO::ibuf, 1, 1 << 21, stdin),
                     ::IO::p1 == ::IO::p2)
                 ? EOF
                 : *::IO::p1++)) {
    if (ch == EOF) return false;
    f = ch != '-';
  }
  x = 0;
  if (f) do
      x = x * 10 + (ch & 15);
    while (
        isdigit(ch = (::IO::p1 == ::IO::p2 &&
                              (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                          fread(::IO::ibuf, 1, 1 << 21, stdin),
                               ::IO::p1 == ::IO::p2)
                          ? EOF
                          : *::IO::p1++)));
  else
    do x = x * 10 - (ch & 15);
    while (
        isdigit(ch = (::IO::p1 == ::IO::p2 &&
                              (::IO::p2 = (::IO::p1 = ::IO::ibuf) +
                                          fread(::IO::ibuf, 1, 1 << 21, stdin),
                               ::IO::p1 == ::IO::p2)
                          ? EOF
                          : *::IO::p1++)));
  return true;
}
void pti(const char& c) {
  (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
       (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
   *::IO::p++ = c);
}
void pti(const char* s) {
  while (*s)
    (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
         (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
     *::IO::p++ = *s++);
}
template <class T>
void pti(T x) {
  char buf[sizeof(T) * 3], *p = buf + 1;
  if (x >= 0)
    *buf = (x % 10) | 48, x /= 10;
  else
    (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
         (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
     *::IO::p++ = '-'),
        *buf = (-(x % 10)) | 48, x = -(x / 10);
  while (x) *p++ = (x % 10) | 48, x /= 10;
  while (p != buf)
    (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
         (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
     *::IO::p++ = *--p);
}
template <class T>
void pri(const T& x) {
  pti(x), (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
               (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
           *::IO::p++ = ' ');
}
template <class T>
void prn(const T& x) {
  pti(x), (::IO::p == ::IO::obuf + sizeof(::IO::obuf) &&
               (fwrite(::IO::obuf, 1, 1 << 21, stdout), ::IO::p = ::IO::obuf),
           *::IO::p++ = '\n');
}
template <class T, class... Args>
bool rei(T&& x, Args&&... args) {
  return rei(std::forward<T>(x)) ? rei(args...) : false;
}
template <class T, class... Args>
void pti(const T& x, const Args&... args) {
  pti(x), pti(args...);
}
template <class T, class... Args>
void pri(const T& x, const Args&... args) {
  pri(x), pri(args...);
}
template <class T, class... Args>
void prn(const T& x, const Args&... args) {
  pri(x), prn(args...);
}
template <class T1, class T2>
T1& cmax(T1& a, const T2& b) {
  return a < b ? a = b : a;
}
template <class T1, class T2>
T1& cmin(T1& a, const T2& b) {
  return a > b ? a = b : a;
}
template <class T>
T lowbit(const T& x) {
  return x & -x;
}
using namespace std;
const long long MAXN = 1.5e5 + 5;
long long pw(long long a, long long b = 998244353 - 2) {
  long long ans = 1;
  while (b) {
    if (b & 1) {
      (ans *= a) %= 998244353;
    }
    b >>= 1;
    (a *= a) %= 998244353;
  }
  return ans;
}
long long n;
long long a[MAXN << 1];
signed main() {
  rei(n);
  for (long long i = 1, i_end = n + n; i <= i_end; ++i) {
    rei(a[i]);
  }
  sort(a + 1, a + n + n + 1);
  long long ans = 0;
  for (long long i = 1, i_end = n; i <= i_end; ++i) {
    ans += a[i + n] - a[i];
  }
  ans %= 998244353;
  long long nj = 1;
  for (long long i = 2, i_end = n; i <= i_end; ++i) {
    (nj *= i) %= 998244353;
  }
  long long n2j = nj;
  for (long long i = n + 1, i_end = n + n; i <= i_end; ++i) {
    (n2j *= i) %= 998244353;
  }
  prn(n2j * pw(nj * nj % 998244353) % 998244353 * ans % 998244353);
  return 0;
}
