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.io.*;
  import java.util.*;
  
  public class Main {
  
      private static final long MOD = 998244353;
  
      static int[] readArray(int size, InputReader in, boolean subOne) {
          int[] a = new int[size];
          for (int i = 0; i < size; i++) {
              a[i] = in.nextInt() + (subOne ? -1 : 0);
          }
          return a;
      }
  
      static long[] readLongArray(int size, InputReader in) {
          long[] a = new long[size];
          for (int i = 0; i < size; i++) {
              a[i] = in.nextLong();
          }
          return a;
      }
  
      public static void main(String[] args) throws FileNotFoundException {
  //        long startTime = System.currentTimeMillis();
  //        PrintWriter out = new PrintWriter(new BufferedOutputStream(new FileOutputStream("cowrect.out")));
          InputReader in = new InputReader(System.in);
  //      InputReader in = new InputReader(new FileInputStream("input.txt"));
          PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
  
          int t = in.nextInt();
          for (int ii = 0; ii < t; ii++) {
              int n = in.nextInt();
              int[] a = readArray(n, in, false);
  
              long[] mexMinusOne = new long[n + 3];
              long[] mexPlusOne = new long[n + 3];
              long[] mexPlusOneMinusOne = new long[n + 3];
  
              for (int i = 0; i < n; i++) {
                  mexPlusOne[a[i]] = (mexPlusOne[a[i]] + mexPlusOne[a[i]]) % MOD;
                  mexMinusOne[a[i]] = (mexMinusOne[a[i]] + mexMinusOne[a[i]]) % MOD;
                  if (a[i] > 0) {
                      mexPlusOne[a[i]] = (mexPlusOne[a[i]] + mexPlusOne[a[i] - 1]) % MOD;
                  } else {
                      mexPlusOne[0] += 1;
                  }
                  if (a[i] > 1) {
                      mexMinusOne[a[i]] = (mexMinusOne[a[i]] + mexPlusOne[a[i] - 2]) % MOD;
                      mexMinusOne[a[i]] = (mexMinusOne[a[i]] + mexPlusOneMinusOne[a[i] - 2]) % MOD;
                  } else if (a[i] == 1) {
                      mexMinusOne[a[i]] += 1;
                  }
                  mexPlusOneMinusOne[a[i]] = (mexPlusOneMinusOne[a[i]] * 2 + mexMinusOne[a[i] + 2]) % MOD;
              }
              long ans = 0;
              for (int i = 0; i <= n+1; i++) {
                  ans = (ans + mexMinusOne[i] + mexPlusOne[i] + mexPlusOneMinusOne[i]) % MOD;
              }
              out.println(ans);
          }
  
          out.close();
      }
  
      private static void outputArray(List<Integer> ans, PrintWriter out, boolean addOne) {
          StringBuilder str = new StringBuilder();
          for (long an : ans) {
              str.append(addOne ? (an + 1) : an).append(" ");
          }
          out.println(str);
  //        out.flush();
      }
  
      private static class InputReader {
          public BufferedReader reader;
          public StringTokenizer tokenizer;
  
          public InputReader(InputStream stream) {
              reader = new BufferedReader(new InputStreamReader(stream), 32768);
              tokenizer = null;
          }
  
          private String next() {
              while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                  try {
                      tokenizer = new StringTokenizer(reader.readLine());
                  } catch (IOException e) {
                      throw new RuntimeException(e);
                  }
              }
              return tokenizer.nextToken();
          }
  
          public String nextString() {
              try {
                  return reader.readLine();
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
  
          public int nextInt() {
              return Integer.parseInt(next());
          }
  
          public long nextLong() {
              return Long.parseLong(next());
          }
  
          public double nextDouble() {
              return Double.parseDouble(next());
          }
  
          public char nextChar() {
              return next().charAt(0);
          }
  
          public String nextWord() {
              return next();
          }
  
          private List<Integer>[] readTree(int n) {
              return readGraph(n, n - 1);
          }
  
          private List<Integer>[] readGraph(int n, int m) {
              List<Integer>[] result = new List[n];
              for (int i = 0; i < n; i++) {
                  result[i] = new ArrayList<>();
              }
              for (int i = 0; i < m; i++) {
                  int u = nextInt() - 1;
                  int v = nextInt() - 1;
                  result[u].add(v);
                  result[v].add(u);
              }
              return result;
          }
  
          private Map<Integer, Long>[] readWeightedGraph(int n, int m) {
              Map<Integer, Long>[] result = new HashMap[n];
              for (int i = 0; i < n; i++) {
                  result[i] = new HashMap<>();
              }
              for (int i = 0; i < m; i++) {
                  int u = nextInt() - 1;
                  int v = nextInt() - 1;
                  long w = nextLong();
                  result[u].put(v, Math.min(w, result[u].getOrDefault(v, Long.MAX_VALUE)));
                  result[v].put(u, Math.min(w, result[v].getOrDefault(u, Long.MAX_VALUE)));
              }
              return result;
          }
  
      }
  }