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.io.*;
  import java.util.*;
  
  public class Main{
  	static int mod=998244353;
  	static long fastpow(long n,long ti) {
  		 if (ti == 0) 
  		        return 1l;
  		if(ti%2==0) {
  			long y=fastpow(n, ti/2);
  			long k=y*y;
  			k%=mod;
  			return k;
  		}
  		else {
  			long y=fastpow(n, ti/2);
  			long k=((n*y)%mod)*y;
  			k%=mod;
  			return k;
  		}
  	}
  	static long modInverse(long x) {
     	return fastpow(x, mod-2);
     }
  	static long[]fac,facInv;
  	static void preProcessNCR(int maxN) {
  		//compute factorial for all numbers smaller than or equal maxN
  		fac=new long[maxN+1];fac[0]=1;
  		for(int i=1;i<fac.length;i++)fac[i]=(fac[i-1]*i)%mod;
  		
  		facInv=new long[fac.length];
  		facInv[fac.length-1]=modInverse(fac[fac.length-1]);//modInverse(n!)
  		for (int i=fac.length-2; i>=0; i--) {
  			//modInverse(x!)=(x+1)/(x+1)!=(x+1)*modInverse((x+1)!)
  			facInv[i]=(facInv[i+1]*(i+1))%mod;
  		}
  	}
  
  	public static long ncr(int n,int r) {
  		if(n<r)return 0;
  		long num=fac[n];
  		long den=(facInv[n-r]*facInv[r])%mod;
  		long ans=(num*den)%mod;
  		return ans;
  	}
  	static void main() throws Exception{
  		int n=sc.nextInt();
  		int[]in=sc.intSortedArr(n);
  		if(in[n-1]-in[n-2]>1) {
  			pw.println(0);
  			return;
  		}
  		int cnt=0;
  		for(int i=0;i<n;i++) {
  			if(in[i]==in[n-1])cnt++;
  		}
  		if(cnt==1) {
  			int cnt2=0;
  			for(int i=0;i<n;i++) {
  				if(in[i]==in[n-2]) {
  					cnt2++;
  				}
  			}
  			long ans=(ncr(n, cnt2+1)*fac[n-cnt2-1])%mod;
  			ans=(ans*cnt2)%mod;
  			ans=(ans*fac[cnt2])%mod;
  			pw.println(ans);
  			return;
  		}
  		pw.println(fac[n]);
  	}
  	public static void main(String[] args) throws Exception{
  		sc=new MScanner(System.in);
  //		sc=new MScanner("altstadt.in");
  		pw = new PrintWriter(System.out);
  		int tc=1;
          tc=sc.nextInt();
          preProcessNCR(300000);
  		for(curt=1;curt<=tc;curt++) {
  //			pw.printf("Case #%d: ", i);
  			main();
  		}
  		
  		pw.flush();
  	}
  	static int curt;
  	static PrintWriter pw;
  	static MScanner sc;
  	static class MScanner {
  		StringTokenizer st;
  		BufferedReader br;
  		public MScanner(InputStream system) {
  			br = new BufferedReader(new InputStreamReader(system));
  		}
  	 
  		public MScanner(String file) throws Exception {
  			br = new BufferedReader(new FileReader(file));
  		}
  	 
  		public String next() throws IOException {
  			while (st == null || !st.hasMoreTokens())
  				st = new StringTokenizer(br.readLine());
  			return st.nextToken();
  		}
  		public int[] intArr(int n) throws IOException {
  	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
  	        return in;
  		}
  		public long[] longArr(int n) throws IOException {
  	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
  	        return in;
  		}
  		public int[] intSortedArr(int n) throws IOException {
  	        int[]in=new int[n];for(int i=0;i<n;i++)in[i]=nextInt();
  	        shuffle(in);
  	        Arrays.sort(in);
  	        return in;
  		}
  		public long[] longSortedArr(int n) throws IOException {
  	        long[]in=new long[n];for(int i=0;i<n;i++)in[i]=nextLong();
  	        shuffle(in);
  	        Arrays.sort(in);
  	        return in;
  		}
  		public Integer[] IntegerArr(int n) throws IOException {
  	        Integer[]in=new Integer[n];for(int i=0;i<n;i++)in[i]=nextInt();
  	        return in;
  		}
  		public Long[] LongArr(int n) throws IOException {
  	        Long[]in=new Long[n];for(int i=0;i<n;i++)in[i]=nextLong();
  	        return in;
  		}
  		public String nextLine() throws IOException {
  			return br.readLine();
  		}
  	 
  		public int nextInt() throws IOException {
  			return Integer.parseInt(next());
  		}
  	 
  		public double nextDouble() throws IOException {
  			return Double.parseDouble(next());
  		}
  	 
  		public char nextChar() throws IOException {
  			return next().charAt(0);
  		}
  	 
  		public long nextLong() throws IOException {
  			return Long.parseLong(next());
  		}
  	 
  		public boolean ready() throws IOException {
  			return br.ready();
  		}
  	 
  		public void waitForInput() throws InterruptedException {
  			Thread.sleep(3000);
  		}
  		
  	}
  	static void dbg(int[]in) {
  		System.out.println(Arrays.toString(in));
  	}
  	static void dbg(long[]in) {
  		System.out.println(Arrays.toString(in));
  	}
  	static void sort(int[]in) {
  		shuffle(in);
  		Arrays.sort(in);
  	}
  	static void sort(long[]in) {
  		shuffle(in);
  		Arrays.sort(in);
  	}
  	static void shuffle(int[]in) {
  		for(int i=0;i<in.length;i++) {
  			int idx=(int)(Math.random()*in.length);
  			int tmp=in[i];
  			in[i]=in[idx];
  			in[idx]=tmp;
  		}
  	}
  	static void shuffle(long[]in) {
  		for(int i=0;i<in.length;i++) {
  			int idx=(int)(Math.random()*in.length);
  			long tmp=in[i];
  			in[i]=in[idx];
  			in[idx]=tmp;
  		}
  	}
  }