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: from __future__ import division, print_function
  import math
  import sys
  import os
  from io import BytesIO, IOBase
  #from collections import deque, Counter, OrderedDict, defaultdict
  #import heapq
  #ceil,floor,log,sqrt,factorial,pow,pi,gcd
  #import bisect
  #from bisect import bisect_left,bisect_right
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
  	newlines = 0
  
  	def __init__(self, file):
  		self._fd = file.fileno()
  		self.buffer = BytesIO()
  		self.writable = "x" in file.mode or "r" not in file.mode
  		self.write = self.buffer.write if self.writable else None
  
  	def read(self):
  		while True:
  			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
  			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):
  		while self.newlines == 0:
  			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
  			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()
  
  	def flush(self):
  		if self.writable:
  			os.write(self._fd, self.buffer.getvalue())
  			self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
  	def __init__(self, file):
  		self.buffer = FastIO(file)
  		self.flush = self.buffer.flush
  		self.writable = self.buffer.writable
  		self.write = lambda s: self.buffer.write(s.encode("ascii"))
  		self.read = lambda: self.buffer.read().decode("ascii")
  		self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  def print(*args, **kwargs):
  	"""Prints the values to a stream, or to sys.stdout by default."""
  	sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
  	at_start = True
  	for x in args:
  		if not at_start:
  			file.write(sep)
  		file.write(str(x))
  		at_start = False
  	file.write(kwargs.pop("end", "\n"))
  	if kwargs.pop("flush", False):
  		file.flush()
  
  
  if sys.version_info[0] < 3:
  	sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
  else:
  	sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  def inp():
      return(int(input()))
  def inps():
      return input().strip()
  def inlt():
      return(list(map(int,input().split())))
  def insr():
      s = input().strip()
      return(list(s[:len(s)]))
  def invr():
      return(map(int,input().split()))
  maxn=998244353
  
  N = 2*10**5+10
   
  factorialNumInverse = [None] * (N + 1)
  naturalNumInverse = [None] * (N + 1)
  fact = [None] * (N + 1)
   
  # Function to precompute inverse of numbers
  def InverseofNumber(p):
      naturalNumInverse[0] = naturalNumInverse[1] = 1
      for i in range(2, N + 1, 1):
          naturalNumInverse[i] = (naturalNumInverse[p % i] *
                                     (p - int(p / i)) % p)
   
  # Function to precompute inverse
  # of factorials
  def InverseofFactorial(p):
      factorialNumInverse[0] = factorialNumInverse[1] = 1
   
      # precompute inverse of natural numbers
      for i in range(2, N + 1, 1):
          factorialNumInverse[i] = (naturalNumInverse[i] *
                                    factorialNumInverse[i - 1]) % p
   
  # Function to calculate factorial of 1 to N
  def factorial(p):
      fact[0] = 1
      for i in range(1, N + 1):
          fact[i] = (fact[i - 1] * i) % p
  def Binomial(N, R, p):
      ans = ((fact[N] * factorialNumInverse[R])% p *
                        factorialNumInverse[N - R])% p
      return ans
  
  fac=[1,1]
  for i in range(2,2*10**5+100):
      fac.append((fac[i-1]*i)%maxn)
  p = maxn
  InverseofNumber(p)
  InverseofFactorial(p)
  factorial(p)
  for _ in range(inp()):
      n=inp()
      l=inlt()
      s=l.copy()
      s.sort()
      if s[-1]-s[-2]>1:
          print(0)
      else:
          mx=max(l)
          cnt=0
          for i in range(n):
              if l[i]==mx:
                  cnt+=1
          if cnt>1:
              # print(n,l)
              print(fac[n])
          else:
              cnt=0
              for i in range(n):
                  if mx-l[i]>=2:
                      cnt+=1
              ans=fac[n]
              for j in range(cnt+1):
                  ans=(ans-fac[n-j-1]*(Binomial(cnt,j,maxn)*fac[j]))%maxn
                  # print(Binomial(n,j,maxn)*fac[j],n,j)
              if ans%maxn>0:
                  print(ans%maxn)
              else:
                  while(ans%maxn<0):
                      ans+=maxn
                  print(ans%maxn)