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 java.util.*;
  import java.io.*;
  
  public class C_Jury_Meeting{
      public static void main(String[] args) {
          FastScanner s= new FastScanner();
          StringBuilder res = new StringBuilder();
          long mod=998244353;
          int size=(int)Math.pow(10,5);
          size=2*size;
          size+=5;
          long factorial[]= new long[size];
          factorial[1]=1;
          factorial[0]=1;
          for(int i=2;i<size;i++){
              long f=i*factorial[i-1];
              f=f%mod;
              factorial[i]=f;
          }
          int t=s.nextInt();
          int p=0;
          while(p<t){
          int n=s.nextInt();
          ArrayList<Long> list = new  ArrayList<Long>();
          for(int i=0;i<n;i++){
              long a=s.nextLong();
              list.add(a);
          }
          
          Collections.sort(list);
          long a=list.get(n-1);
          long b=list.get(n-2);
          if(a==b){
              long ans=factorial[n];
             
              res.append(ans+"\n");
          }
          else if(b+1==a){
              int count=0;
              long num=b;
              for(int i=0;i<n;i++){
                  if(list.get(i)==num){
                      count++;
                  }
              }
              int remain=n-count-1;
              long ans=0;
              for(int i=n-1;i>=count;i--){
                  int here=i;
                  int there=n-i-1;
                  int choose=here-count;
                  long yo=(factorial[here]*factorial[there])%mod;
                  long a1=factorial[remain];
                  long a2=factorial[remain-choose];
                  long a3=factorial[choose];
                  long a22=modInverse(a2,mod);
                  long a33=modInverse(a3,mod);
                  long yo1=(a1*a22)%mod;
                  yo1=(yo1*a33)%mod;
                  yo=(yo*yo1)%mod;
                  ans+=yo;
                  ans=ans%mod;
  
  
  
  
  
              }
              long comp=factorial[n];
              comp=comp-ans+mod;
              comp=comp%mod;
              res.append(comp+"\n");
  
  
  
          }
          else{
              res.append("0\n");
          }
          p++;
      }
      System.out.println(res);
      }
      static long power(long x, long y, long m)
      {
          if (y == 0)
              return 1;
          long p = power(x, y / 2, m) % m;
          p = (long)((p * (long)p) % m);
          if (y % 2 == 0)
              return p;
          else
              return (long)((x * (long)p) % m);
      }
      static long gcd(long a, long b)
      {
          if (a == 0)
              return b;
          return gcd(b % a, a);
      }
      static long modInverse(long a, long m)
      {
          long g = gcd(a, m);
         return power(a, m - 2, m);
          
          
              // If a and m are relatively prime, then modulo
              // inverse is a^(m-2) mode m
             
          
      }
      static class FastScanner {
  		BufferedReader br;
  		StringTokenizer st;
   
  		public FastScanner(String s) {
  			try {
  				br = new BufferedReader(new FileReader(s));
  			} catch (FileNotFoundException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
   
  		public FastScanner() {
  			br = new BufferedReader(new InputStreamReader(System.in));
  		}
   
  		String nextToken() {
  			while (st == null || !st.hasMoreElements()) {
  				try {
  					st = new StringTokenizer(br.readLine());
  				} catch (IOException e) {
  					// TODO Auto-generated catch block
  					e.printStackTrace();
  				}
  			}
  			return st.nextToken();
  		}
   
  		int nextInt() {
  			return Integer.parseInt(nextToken());
  		}
   
  		long nextLong() {
  			return Long.parseLong(nextToken());
  		}
   
  		double nextDouble() {
  			return Double.parseDouble(nextToken());
  		}
  	}
  
  
  
  
  }