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
  import math
  import bisect
  from sys import stdin, stdout
  from math import gcd, floor, sqrt, log2, ceil
  from collections import defaultdict as dd
  from bisect import bisect_left as bl, bisect_right as br
  from bisect import insort
  from collections import Counter
  from collections import deque
  from heapq import heappush,heappop,heapify
  from itertools import permutations,combinations
  from itertools import accumulate as ac
  from random import randint as ri
  mod = int(1e9)+7
  mod = 998244353
   
  ip = lambda : int(stdin.readline())
  inp = lambda: map(int,stdin.readline().split())
  ips = lambda: stdin.readline().rstrip()
  out = lambda x : stdout.write(str(x)+"\n")
  
  nn = int(3e5)+1
  f = 1
  fact = [None]*nn
  fact[0] = 1
  for i in range(1,nn):
      f *= i
      f %= mod
      fact[i] = f
  
  t = ip()
  for _ in range(t):
      n = ip()
      arr = list(inp())
      dic = Counter(arr)
      cur = max(arr)
      if dic[cur] >= 2:
          ans = fact[n]
  
      else:
          ct = 0
          for i in arr:
              if i == cur-1:
                  ct += 1
  
          if ct == 0:
              ans = 0
  
          else:
              ans = 0
              left = n
              for i in range(n):
                  left -= 1
                  if left>= ct:
                      
                      num = fact[left]
                      den = fact[left-ct]
                      g = gcd(num,den)
                      num //= g
                      den //= g
                      val = (pow(den,mod-2,mod)*num)%mod
                      rem = n-ct-1
                      val *= fact[rem]
                      val %= mod
                      ans += val
                      ans %= mod
              
  
              ans = fact[n]-ans
              ans %= mod
  
      print(ans)
      
              
                  
          
              
      
      
              
  
              
  
              
              
  
              
  
              
              
              
  
      
      
  