description: n people gathered to hold a jury meeting of the upcoming competition, the i-th member of the jury came up with a_i tasks, which they want to share with each other.
  
  First, the jury decides on the order which they will follow while describing the tasks. Let that be a permutation p of numbers from 1 to n (an array of size n where each integer from 1 to n occurs exactly once).
  
  Then the discussion goes as follows:
  
    * If a jury member p_1 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. 
    * If a jury member p_2 has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. 
    * ... 
    * If a jury member p_n has some tasks left to tell, then they tell one task to others. Otherwise, they are skipped. 
    * If there are still members with tasks left, then the process repeats from the start. Otherwise, the discussion ends. 
  
  
  
  A permutation p is nice if none of the jury members tell two or more of their own tasks in a row. 
  
  Count the number of nice permutations. The answer may be really large, so print it modulo 998 244 353.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
  
  The first line of the test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — number of jury members.
  
  The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of problems that the i-th member of the jury came up with.
  
  The sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case, print one integer — the number of nice permutations, taken modulo 998 244 353.
  
  Example
  
  Input
  
  
  4
  2
  1 2
  3
  5 5 5
  4
  1 3 3 7
  6
  3 4 2 1 3 3
  
  
  Output
  
  
  1
  6
  0
  540
  
  Note
  
  Explanation of the first test case from the example:
  
  There are two possible permutations, p = [1, 2] and p = [2, 1]. For p = [1, 2], the process is the following:
  
    1. the first jury member tells a task; 
    2. the second jury member tells a task; 
    3. the first jury member doesn't have any tasks left to tell, so they are skipped; 
    4. the second jury member tells a task. 
  
  
  
  So, the second jury member has told two tasks in a row (in succession), so the permutation is not nice.
  
  For p = [2, 1], the process is the following:
  
    1. the second jury member tells a task; 
    2. the first jury member tells a task; 
    3. the second jury member tells a task. 
  
  
  
  So, this permutation is nice.
solution: # mod=1000000007 
  # MOD THE ANSWER IF USING THIS
  mod=998244353
  def main():
      
      max_n=200005
      nCr,fact =  make_nCr_mod(max_n,mod)
      
      tc=ri()
      for i in range(tc): 
          n=ri()
          a=ria()
          a=sorted(a)
          cnt=Counter(a)
          if a[-1]-a[-2]>=2:
              wi(0)
              continue
          if cnt[a[-1]]>=2:
              wi(fact[n])
          else:     
              k=cnt[a[-1]-1]
              # only thing that matters is subsequence which has a[-1] and k a[-1]-1
              # let a[-1] be p and a[-1]-1 be q
              # p can take any place in the subsequence except last position
              # length of subsequence is k+1 and p can take first k positions so atleast 1 q comes after p
              # ratio of permutation that workds is k/(k+1) for all permutations
              # ans = (total permutations) *(k/(k+1))
              wi((k*fact[n]*modinv(k+1))%mod)
  
          
  def rant():
      # RANT BEGINS-
      # 
      # Did you look at the constraints dummy? Read problem again carefully understand it correctly
      # Are base cases correct n=0,n=1,n=N or string is all 0 or all 1?
      # Take hints from time limits maybe n=1000 and m=100000 so if n^2 doesnt work n*m might work?? 
      # Upto 10^8 works under 2 sec
      # 
      # 1.Greedy? What matters what doesnt? Is my claim correct? 
      #   Does my implementation correctly implements the greedy i thought of? 
      #   Dictionary? keep a count of values if constraint on something is low(like only alphabets(26) count)? 
      # 
      # 2.DP? Think about state's ranges maybe one of the states have lesser possible values than it may look like? 
      #   Obviously think about order of evaluation?
      #   Max/Min Answer including ith element or Ways to Answer using first i elements?
      # 
      # 3.Binary Search?(Monotonic? any one directed order in which we have to perform something?)
      # 
      # 4.Graph?DSU?Edge property or Vertex property Read carefully? Bipartitenes Property??? Cycle Property??? 
      #   Hidden but dependency ordering of values(in 1d array or 2d Table/Array) is that of a graph???
      # 
      # 5.Number Theory?(GCD subtraction?)
      # 
      # 6.Bruteforce?(Redundant part of N which may not give answer?Constraints?)
      # 
      # 7.Range Queries?
      # 
      # 8.Any Equivalency?(We have A and B and have to do 
      #   something between them maybe difficult if there was A~C and C~B then A~B
      #   C could be max or min or some other thing)
      # 
      # 9.Reverse Engineering?(From Answer to quesn or last step to first step)
      #   (if i to i+1 formula not making sense make i to i-1 formula)
      #
      # 10.Constructive? Mod? Bruteforce for smaller case and analyze patterns?
      #
      # 11.String? Constructive Greedy example- 
      #   Bracket sequence make first part unknown open and second part unknown closed 
      #   Remember always only n//2 open and n//2 closed brackets are there
      #
      # 12.Combinatorics?--> (n to i-1 index ways) * (ith index ways) * Ways (for i-1 till 0 index)?
      #
      # 13.Look for patterns and dependency of the patterns(maybe only first row or column matters to construct other rows and columns)
      #   for smaller cases maybe make bruteforce solution and analyze the patterns
      # 
      # 14.Two-Pointer Solution or Optimization??
      # 
      # 15.Sets & Multisets faster and easier to copy in CPP
      # 
      # 16.Critical Observations-Observe carefully and think about effects of something happening given in quesn.
      #   For example-Maybe complex problem for all posns can be broken into easier sub problem for Even positions and Odd positions.
      #   because if observed carefully even and odd positions are getting affected independently then we can combine answer 
      #
      # RANT ENDS
      return "AAAAAAAAAAAAAAAAARRRGHHHHHHHHHHHHHHHHHHHHHHHH"
  
  def modinv(n):
      return pow(n,mod-2,mod)
  
  def position_dict(arr):
      posn={}
      for i in range(len(arr)):
          if arr[i] in posn:
              posn[arr[i]].append(i)
          else:
              posn[arr[i]]=[i]
      return posn
  
  def SieveOfEratosthenes(limit):
      """Returns all primes not greater than limit."""
      isPrime = [True]*(limit+1)
      isPrime[0] = isPrime[1] = False
      primes = []
      for i in range(2, limit+1):
          if not isPrime[i]:continue
          primes += [i]
          for j in range(i*i, limit+1, i):
              isPrime[j] = False
      return primes
  
  def memodict(f):
      """memoization decorator for a function taking a single argument"""
      class memodict(dict):
          def __missing__(self, key):
              ret = self[key] = f(key)
              return ret
  
      return memodict().__getitem__
  
  def pollard_rho(n):
      """returns a random factor of n"""
      if n & 1 == 0:
          return 2
      if n % 3 == 0:
          return 3
  
      s = ((n - 1) & (1 - n)).bit_length() - 1
      d = n >> s
      for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
          p = pow(a, d, n)
          if p == 1 or p == n - 1 or a % n == 0:
              continue
          for _ in range(s):
              prev = p
              p = (p * p) % n
              if p == 1:
                  return math.gcd(prev - 1, n)
              if p == n - 1:
                  break
          else:
              for i in range(2, n):
                  x, y = i, (i * i + 1) % n
                  f = math.gcd(abs(x - y), n)
                  while f == 1:
                      x, y = (x * x + 1) % n, (y * y + 1) % n
                      y = (y * y + 1) % n
                      f = math.gcd(abs(x - y), n)
                  if f != n:
                      return f
      return n
  
  @memodict
  def prime_factors(n):
      """returns a Counter of the prime factorization of n"""
      if n <= 1:
          return Counter()
      f = pollard_rho(n)
      return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)
  
  def distinct_factors(n):
      """returns a list of all distinct factors of n"""
      factors = [1]
      for p, exp in prime_factors(n).items():
          factors += [p**i * factor for factor in factors for i in range(1, exp + 1)]
      return factors
  
  def all_factors(n):
      """returns a sorted list of all distinct factors of n"""
      small, large = [], []
      for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
          if not n % i:
              small.append(i)
              large.append(n // i)
      if small[-1] == large[-1]:
          large.pop()
      large.reverse()
      small.extend(large)
      return small
  
  def make_nCr_mod(max_n=2 * 10**5, mod=10**9 + 7):
      max_n = min(max_n, mod - 1)
  
      fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)
      fact[0] = 1
      for i in range(max_n):
          fact[i + 1] = fact[i] * (i + 1) % mod
  
      inv_fact[-1] = pow(fact[-1], mod - 2, mod)
      for i in reversed(range(max_n)):
          inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod
  
      def nCr_mod(n, r):
          res = 1
          while n or r:
              a, b = n % mod, r % mod
              if a < b:
                  return 0
              res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod
              n //= mod
              r //= mod
          return res
  
      return nCr_mod,fact
  
  class DisjointSetUnion:
      def __init__(self, n):
          self.parent = [*range(n+1)]
          self.size = [1]*(n+1)
          self.min, self.max = [*range(n+1)], [*range(n+1)]
          self.count = n
  
      def get(self, a):
          """Returns the identifier (parent) of the set to which a belongs to!"""
          if self.parent[a] == a:
              return a
          x = a
          while a != self.parent[a]:
              a = self.parent[a]
          while x != self.parent[x]:
              self.parent[x], x = a, self.parent[x]
          return a
  
      def union(self, a, b):
          """Join two sets that contain a and b!"""
          a, b = self.get(a), self.get(b)
          if a != b:
              if self.size[a] > self.size[b]:
                  a, b = b, a
              self.parent[a] = b
              self.size[b] += self.size[a]
              self.min[b] = min(self.min[a], self.min[b])
              self.max[b] = max(self.max[a], self.max[b])
              self.count -= 1
  
      def sz(self,a):
          return self.size[self.get(a)]
      
      def count_sets(self):
          """Returns the number of disjoint sets!"""
          return self.count
      
  class SegmentTree:
      
      
      
      def __init__(self, data, default=0, func=max):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          """func of data[start, stop]"""
          stop+=1
          start += self._size
          stop += self._size
  
          res_left = res_right = self._default
          while start < stop:
              if start & 1:
                  res_left = self._func(res_left, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res_right = self._func(self.data[stop], res_right)
              start >>= 1
              stop >>= 1
  
          return self._func(res_left, res_right)
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  class SparseTable:
      def __init__(self, data, func=min):
          self.func = func
          self._data = _data = [list(data)]
          i, n = 1, len(_data[0])
          while 2 * i <= n:
              prev = _data[-1]
              _data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])
              i <<= 1
  
      def query(self, start, stop):
          """func of data[start, stop)]"""
          depth = (stop + 1 - start).bit_length() - 1
          return self.func(self._data[depth][start], self._data[depth][stop + 1 - (1 << depth)])
  
      def __getitem__(self, idx):
          return self._data[0][idx]
                
  class SortedList:
      def __init__(self, iterable=[], _load=200):
          """Initialize sorted list instance."""
          values = sorted(iterable)
          self._len = _len = len(values)
          self._load = _load
          self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
          self._list_lens = [len(_list) for _list in _lists]
          self._mins = [_list[0] for _list in _lists]
          self._fen_tree = []
          self._rebuild = True
   
      def _fen_build(self):
          """Build a fenwick tree instance."""
          self._fen_tree[:] = self._list_lens
          _fen_tree = self._fen_tree
          for i in range(len(_fen_tree)):
              if i | i + 1 < len(_fen_tree):
                  _fen_tree[i | i + 1] += _fen_tree[i]
          self._rebuild = False
   
      def _fen_update(self, index, value):
          """Update `fen_tree[index] += value`."""
          if not self._rebuild:
              _fen_tree = self._fen_tree
              while index < len(_fen_tree):
                  _fen_tree[index] += value
                  index |= index + 1
   
      def _fen_query(self, end):
          """Return `sum(_fen_tree[:end])`."""
          if self._rebuild:
              self._fen_build()
   
          _fen_tree = self._fen_tree
          x = 0
          while end:
              x += _fen_tree[end - 1]
              end &= end - 1
          return x
   
      def _fen_findkth(self, k):
          """Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
          _list_lens = self._list_lens
          if k < _list_lens[0]:
              return 0, k
          if k >= self._len - _list_lens[-1]:
              return len(_list_lens) - 1, k + _list_lens[-1] - self._len
          if self._rebuild:
              self._fen_build()
   
          _fen_tree = self._fen_tree
          idx = -1
          for d in reversed(range(len(_fen_tree).bit_length())):
              right_idx = idx + (1 << d)
              if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
                  idx = right_idx
                  k -= _fen_tree[idx]
          return idx + 1, k
   
      def _delete(self, pos, idx):
          """Delete value at the given `(pos, idx)`."""
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
   
          self._len -= 1
          self._fen_update(pos, -1)
          del _lists[pos][idx]
          _list_lens[pos] -= 1
   
          if _list_lens[pos]:
              _mins[pos] = _lists[pos][0]
          else:
              del _lists[pos]
              del _list_lens[pos]
              del _mins[pos]
              self._rebuild = True
   
      def _loc_left(self, value):
          """Return an index pair that corresponds to the first position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
   
          _lists = self._lists
          _mins = self._mins
   
          lo, pos = -1, len(_lists) - 1
          while lo + 1 < pos:
              mi = (lo + pos) >> 1
              if value <= _mins[mi]:
                  pos = mi
              else:
                  lo = mi
   
          if pos and value <= _lists[pos - 1][-1]:
              pos -= 1
   
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value <= _list[mi]:
                  idx = mi
              else:
                  lo = mi
   
          return pos, idx
   
      def _loc_right(self, value):
          """Return an index pair that corresponds to the last position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
   
          _lists = self._lists
          _mins = self._mins
   
          pos, hi = 0, len(_lists)
          while pos + 1 < hi:
              mi = (pos + hi) >> 1
              if value < _mins[mi]:
                  hi = mi
              else:
                  pos = mi
   
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value < _list[mi]:
                  idx = mi
              else:
                  lo = mi
   
          return pos, idx
   
      def add(self, value):
          """Add `value` to sorted list."""
          _load = self._load
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
   
          self._len += 1
          if _lists:
              pos, idx = self._loc_right(value)
              self._fen_update(pos, 1)
              _list = _lists[pos]
              _list.insert(idx, value)
              _list_lens[pos] += 1
              _mins[pos] = _list[0]
              if _load + _load < len(_list):
                  _lists.insert(pos + 1, _list[_load:])
                  _list_lens.insert(pos + 1, len(_list) - _load)
                  _mins.insert(pos + 1, _list[_load])
                  _list_lens[pos] = _load
                  del _list[_load:]
                  self._rebuild = True
          else:
              _lists.append([value])
              _mins.append(value)
              _list_lens.append(1)
              self._rebuild = True
   
      def discard(self, value):
          """Remove `value` from sorted list if it is a member."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_right(value)
              if idx and _lists[pos][idx - 1] == value:
                  self._delete(pos, idx - 1)
   
      def remove(self, value):
          """Remove `value` from sorted list; `value` must be a member."""
          _len = self._len
          self.discard(value)
          if _len == self._len:
              raise ValueError('{0!r} not in list'.format(value))
   
      def pop(self, index=-1):
          """Remove and return value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          value = self._lists[pos][idx]
          self._delete(pos, idx)
          return value
   
      def bisect_left(self, value):
          """Return the first index to insert `value` in the sorted list."""
          pos, idx = self._loc_left(value)
          return self._fen_query(pos) + idx
   
      def bisect_right(self, value):
          """Return the last index to insert `value` in the sorted list."""
          pos, idx = self._loc_right(value)
          return self._fen_query(pos) + idx
   
      def count(self, value):
          """Return number of occurrences of `value` in the sorted list."""
          return self.bisect_right(value) - self.bisect_left(value)
   
      def __len__(self):
          """Return the size of the sorted list."""
          return self._len
   
      def __getitem__(self, index):
          """Lookup value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          return self._lists[pos][idx]
   
      def __delitem__(self, index):
          """Remove value at `index` from sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          self._delete(pos, idx)
   
      def __contains__(self, value):
          """Return true if `value` is an element of the sorted list."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_left(value)
              return idx < len(_lists[pos]) and _lists[pos][idx] == value
          return False
   
      def __iter__(self):
          """Return an iterator over the sorted list."""
          return (value for _list in self._lists for value in _list)
   
      def __reversed__(self):
          """Return a reverse iterator over the sorted list."""
          return (value for _list in reversed(self._lists) for value in reversed(_list))
   
      def __repr__(self):
          """Return string representation of sorted list."""
          return 'SortedList({0})'.format(list(self))
  
  import sys, os, io ,copy
  def rs(): return sys.stdin.readline().rstrip()
  def ri(): return int(sys.stdin.readline())
  def ria(): return list(map(int, sys.stdin.readline().split()))
  def ws(s): sys.stdout.write(s + '\n')
  def wi(n): sys.stdout.write(str(n) + '\n')
  def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
  import math,datetime,functools,itertools,operator,bisect,fractions,statistics
  from math import log2
  from bisect import bisect_left,bisect_right
  from collections import deque,defaultdict,OrderedDict,Counter
  from fractions import Fraction
  from decimal import Decimal
  from sys import stdout
  from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
  # sys.setrecursionlimit(111111) 
  INF=999999999999999999999999
  alphabets="abcdefghijklmnopqrstuvwxyz"
  
  class FastReader(io.IOBase):
      newlines = 0
  
      def __init__(self, fd, chunk_size=1024 * 8):
          self._fd = fd
          self._chunk_size = chunk_size
          self.buffer = io.BytesIO()
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self, size=-1):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
  class FastWriter(io.IOBase):
  
      def __init__(self, fd):
          self._fd = fd
          self.buffer = io.BytesIO()
          self.write = self.buffer.write
  
      def flush(self):
          os.write(self._fd, self.buffer.getvalue())
          self.buffer.truncate(0), self.buffer.seek(0)
  
  class FastStdin(io.IOBase):
      def __init__(self, fd=0):
          self.buffer = FastReader(fd)
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  class FastStdout(io.IOBase):
      def __init__(self, fd=1):
          self.buffer = FastWriter(fd)
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.flush = self.buffer.flush
  
  if __name__ == '__main__':
      sys.stdin = FastStdin()
      sys.stdout = FastStdout()
      starttime=datetime.datetime.now()
      if(os.path.exists('input.txt')):
          sys.stdin = open("input.txt","r")
          sys.stdout = open("output.txt","w")
      main()
      endtime=datetime.datetime.now()
      time=(endtime-starttime).total_seconds()*1000
      if(os.path.exists('input.txt')):
          print("Time:",time,"ms")  
      