description: Let's call a sequence of integers x_1, x_2, ..., x_k MEX-correct if for all i (1 ≤ i ≤ k) |x_i - \operatorname{MEX}(x_1, x_2, ..., x_i)| ≤ 1 holds. Where \operatorname{MEX}(x_1, ..., x_k) is the minimum non-negative integer that doesn't belong to the set x_1, ..., x_k. For example, \operatorname{MEX}(1, 0, 1, 3) = 2 and \operatorname{MEX}(2, 1, 5) = 0.
  
  You are given an array a consisting of n non-negative integers. Calculate the number of non-empty MEX-correct subsequences of a given array. The number of subsequences can be very large, so print it modulo 998244353. 
  
  Note: a subsequence of an array a is a sequence [a_{i_1}, a_{i_2}, ..., a_{i_m}] meeting the constraints 1 ≤ i_1 < i_2 < ... < i_m ≤ n. If two different ways to choose the sequence of indices [i_1, i_2, ..., i_m] yield the same subsequence, the resulting subsequence should be counted twice (i. e. two subsequences are different if their sequences of indices [i_1, i_2, ..., i_m] are not the same).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
  
  The first line of each test case contains a single integer n (1 ≤ n ≤ 5 ⋅ 10^5).
  
  The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ n).
  
  The sum of n over all test cases doesn't exceed 5 ⋅ 10^5.
  
  Output
  
  For each test case, print a single integer — the number of non-empty MEX-correct subsequences of a given array, taken modulo 998244353.
  
  Example
  
  Input
  
  
  4
  3
  0 2 1
  2
  1 0
  5
  0 0 0 0 0
  4
  0 1 2 3
  
  
  Output
  
  
  4
  2
  31
  7
  
  Note
  
  In the first example, the valid subsequences are [0], [1], [0,1] and [0,2].
  
  In the second example, the valid subsequences are [0] and [1].
  
  In the third example, any non-empty subsequence is valid. 
solution: import java.util.*;
  
  import java.io.*;
  
  public class tr0 {
  	static PrintWriter out;
  	static StringBuilder sb;
  	static long mod = (long) 998244353;
  	static long inf = (long) 1e16;
  	static int n, m;
  	static ArrayList<Integer>[] ad;
  	static int[][] remove, add;
  	static int[][][] memo;
  	static boolean vis[];
  	static long[] inv, f, ncr[];
  	static HashMap<Integer, Integer> hm;
  	static int[] pre, suf, Smax[], Smin[];
  	static int idmax, idmin;
  	static ArrayList<Integer> av;
  	static HashMap<Integer, Integer> mm;
  	static boolean[] msks;
  	static int[] lazy[], lazyCount;
  	static int[] dist;
  	static int[][] P;
  	static long N;
  	static ArrayList<Integer> gl;
  	static int[] a, b;
  	static String s;
  
  	public static void main(String[] args) throws Exception {
  		Scanner sc = new Scanner(System.in);
  		out = new PrintWriter(System.out);
  		int t = sc.nextInt();
  		while (t-- > 0) {
  			int n = sc.nextInt();
  			int[] a = new int[n];
  			int ones = 0;
  			int zeros = 0;
  			int[] occ = new int[n + 10];
  			for (int i = 0; i < n; i++) {
  				a[i] = sc.nextInt();
  				if (a[i] == 1)
  					ones++;
  				if (a[i] == 0)
  					zeros++;
  				occ[a[i]]++;
  			}
  			long ans = (modPow(2, ones) - 1 + mod) % mod;
  			long[] dps = new long[n + 10];
  			for (int i = 0; i < n; i++) {
  				int num = a[i];
  				occ[num]--;
  				long x = (1 + dps[num]) % mod;
  				if (num > 0)
  					x = (dps[num - 1] + dps[num]) % mod;
  				dps[num] = (dps[num] + x) % mod;
  				ans%=mod;
  				if (num < 2)
  					continue;
  				int numx = num - 2;
  				long ox = occ[numx] + occ[num];
  				ox = (modPow(2, ox)  + mod) % mod;
  				long j = (ox * dps[numx]) % mod;
  				ans = (ans + j) % mod;
  		//		System.out.println(ans + " " + ox);
  			}
  			for (int i = 0; i < dps.length; i++) {
  				ans = (ans + dps[i]) % mod;
  			}
  			out.println(ans);
  		}
  		out.flush();
  	}
  
  	static long modPow(long a, long e)
  
  	{
  		long res = 1;
  		while (e > 0) {
  			if ((e & 1) == 1)
  				res = (res * a) % mod;
  			a = (a * a) % mod;
  			e >>= 1;
  		}
  		return res;
  	}
  
  	static class Scanner {
  		StringTokenizer st;
  		BufferedReader br;
  
  		public Scanner(InputStream system) {
  			br = new BufferedReader(new InputStreamReader(system));
  		}
  
  		public Scanner(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 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 int[] nextArrInt(int n) throws IOException {
  			int[] a = new int[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextInt();
  			return a;
  		}
  
  		public long[] nextArrLong(int n) throws IOException {
  			long[] a = new long[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextLong();
  			return a;
  		}
  
  		public int[] nextArrIntSorted(int n) throws IOException {
  			int[] a = new int[n];
  			Integer[] a1 = new Integer[n];
  			for (int i = 0; i < n; i++)
  				a1[i] = nextInt();
  			Arrays.sort(a1);
  			for (int i = 0; i < n; i++)
  				a[i] = a1[i].intValue();
  			return a;
  		}
  
  		public long[] nextArrLongSorted(int n) throws IOException {
  			long[] a = new long[n];
  			Long[] a1 = new Long[n];
  			for (int i = 0; i < n; i++)
  				a1[i] = nextLong();
  			Arrays.sort(a1);
  			for (int i = 0; i < n; i++)
  				a[i] = a1[i].longValue();
  			return a;
  		}
  
  		public boolean ready() throws IOException {
  			return br.ready();
  		}
  
  		public void waitForInput() throws InterruptedException {
  			Thread.sleep(3000);
  		}
  	}
  }