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: import sys,math
  from collections import deque,defaultdict
  import operator as op
  from functools import reduce
  from itertools import permutations
  import heapq
  
  #sys.setrecursionlimit(10**7) 
  # OneDrive\Documents\codeforces
  
  I=sys.stdin.readline
  
  alpha="abcdefghijklmnopqrstuvwxyz"
  
  mod=10**9 + 7
  
  """
  x_move=[-1,0,1,0,-1,1,1,-1]
  y_move=[0,1,0,-1,1,1,-1,-1]
  """
  def ii():
  	return int(I().strip())
  def li():
  	return list(map(int,I().strip().split()))
  def mi():
  	return map(int,I().strip().split())
  
  
  def ncr(n, r):
      r = min(r, n-r)
      numer = reduce(op.mul, range(n, n-r, -1), 1)
      denom = reduce(op.mul, range(1, r+1), 1)
      return numer // denom 
  
  def mod_ncr(n, r, p):
      return (fact[n] * pow(fact[r]*fact[n-r],p - 2, p)) % p
  
  def ispali(s):
  	i=0
  	j=len(s)-1
  
  	while i<j:
  		if s[i]!=s[j]:
  			return False
  		i+=1
  		j-=1
  	return True
  
  
  
  def isPrime(n):
  	if n<=1:
  		return False
  	elif n<=2:
  		return True
  	else:
  		
  		for i in range(2,int(n**.5)+1):
  			if n%i==0:
  				return False
  		return True
  mod=998244353
  fact=[1]*(3*10**5)
  for i in range(2,3*10**5):
  	fact[i]=(fact[i-1]*i)%mod
  
  
  def main():
  	ans=""
  	
  	for _ in range(ii()):
  		n=ii()
  		arr=sorted(li())
  		mx=arr[-1]
  
  		if arr.count(mx)>1:
  			ans+=str(fact[n])+"\n"
  		else:
  			mx2=arr[-2]
  			if mx-mx2>1:
  				ans+="0\n"
  			else:
  				x=fact[n]
  				cnt_mx2=arr.count(mx2)
  				tmp=0
  				for i in range(n-1,cnt_mx2-1,-1):
  					tmp+=(mod_ncr(i,cnt_mx2,mod))%mod
  				# print(tmp)
  				tmp%=mod
  
  				tmp=(fact[n-cnt_mx2-1]*fact[cnt_mx2]*tmp)%mod
  				ans+=str((x-tmp)%mod)+"\n"
  	print(ans)
  
  
  		
  		
  	
  
  
  
  
  		
  	
  	
  			
  
  	
  
  
  	
  
  
  
  
  
  
  
  
  
  
  
  
  
  		
  
  		
  
  
  		
  
  
  
  
  
  
  
  
  
  		
  
  
  
  		
  
  
  
  
  
  
  
  	
  
  	
  
  
  	
  	
  
  	
  
  
  
  
  	
  
  
   
  		
  
  
  
  
  
  	
  
  	
  
  
  			
  
  
  
  
  
  
  
  
  
  	
  
  
  				
  
  
  	
  
  	
  	
  
  	
  
  
  
  
  	
  
  
  	
  
  
  
  
  		
  	
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  					
  
  if __name__ == '__main__':
  	main()