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.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.*;
public class c731 {

	public static void main(String[] args) throws IOException {
//try {
FastReader sc = new FastReader();
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
int t = sc.nextInt();
int m = 998244353;
long[] fac = new long[200001];
fac[0] =1;
fac[1] = 1;
for(int i = 2 ; i<200001;i++) {
	fac[i] = (fac[i-1]*i)%m;
}
//for(int i = 0 ; i<22; i++) {
//	System.out.print(fac[i] + " ");
//}
for(int o = 0 ; o<t;o++) {
int n = sc.nextInt();
//int[] arr = new int[n];
ArrayList<Integer> al = new ArrayList<Integer>();
for(int i =  0 ; i<n;i++) {
	al.add(sc.nextInt());
}
Collections.sort(al);
if(al.get(n-1)== al.get(n-2)) {
	System.out.println(fac[n]);
}else if(al.get(n-1)-al.get(n-2)>1) {
	System.out.println(0);
}else {
	int x = 0;
	int j = n-2;
	while(j>=0 && al.get(n-1) - al.get(j) == 1) {
		x ++;
	j--;
	}
	int y = n-x-1;
	long val = 0;
//	System.out.println("y = " + y);
	for(int i = 1 ; i<=y;i++) {
//		val = (val%m + (((ncr(y, i, m, fac)*fac[i])%m)%m*fac[n-i-1]%m)%m + m)%m;
		long c =  mul(mul(ncr(y,i,m,fac),fac[i],m),fac[n-i-1],m);
	val = add(val,c,m);
//	System.out.println("ncr = " + ncr(y,i,m,fac));
//	System.out.println("val = " + val);
	}
	long ans = (fac[n]%m - fac[n-1]%m + m)%m;
	ans = (ans%m - val%m + m) % m;
	System.out.println(ans);
//	System.out.println((fac[n]%m-(ncr(n,x+1,m,fac)%m*fac[x]%m*fac[n-x-1]%m + m)%m));
//long h = mul((mul(ncr(n,x+1,m,fac),fac[x],m)),fac[n-x-1],m);
//System.out.println((fac[n]%m - h %m + m)%m);

}


}

	}
	
	public static long add(long a , long b , int m) {
		return(a%m + b%m + m)%m;
	}
	public static long mul(long a , long b , int m) {
		return (a* b) %m;
	}
	
	public static long power(long x, int y, int p)
	    {
	 
	        long res = 1;
	 
	        x = x % p;
	 
	        while (y > 0) {
	 
	            if (y % 2 == 1)
	                res = (res * x) % p;
	 
	            y = y >> 1; 
	            x = (x * x) % p;
	        }
	 
	        return res;
	    }
	 
	    public static long modInverse(long n, int p)
	    {
	        return power(n, p - 2, p);
	    }
	 
	   public static long ncr(int n, int r,
	                             int p,long[] fac)
	    {
	 
	          if (n<r)
	              return 0;
	        if (r == 0)
	            return 1;
	 
	   
//	        int[] fac = new int[n + 1];
//	        fac[0] = 1;
//	 
//	        for (int i = 1; i <= n; i++)
//	            fac[i] = fac[i - 1] * i % p;
	 
	        return (fac[n] * modInverse(fac[r], p)
	                % p * modInverse(fac[n - r], p)
	                % p)
	            % p;
	    }


}


class FastReader {
    BufferedReader br;
    StringTokenizer st;

    public FastReader()
    {
        br = new BufferedReader(
            new InputStreamReader(System.in));
    }

    String next()
    {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());

            
            
            
            
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() { return Integer.parseInt(next()); }

    long nextLong() { return Long.parseLong(next()); }

    double nextDouble()
    {
        return Double.parseDouble(next());
    }

    String nextLine()
    {
        String str = "";
        try {
            str = br.readLine();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}