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 os
  import sys
  from io import BytesIO, IOBase
  from collections import Counter
  import math as mt
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  
  def gcd(a, b):
      if a == 0:
          return b
      return gcd(b % a, a)
  
  
  def lcm(a, b):
      return (a * b) / gcd(a, b)
  
  
  mod = 998244353
  
  
  def power(k, n):
      if n == 0:
          return 1
      if n % 2:
          return (power(k, n - 1) * k) % mod
      t = power(k, n // 2)
      return (t * t) % mod
  
  
  def totalPrimeFactors(n):
      count = 0
      if (n % 2) == 0:
          count += 1
          while (n % 2) == 0:
              n //= 2
  
      i = 3
      while i * i <= n:
          if (n % i) == 0:
              count += 1
              while (n % i) == 0:
                  n //= i
          i += 2
      if n > 2:
          count += 1
      return count
  
  
  # #MAXN = int(1e7 + 1)
  # # spf = [0 for i in range(MAXN)]
  #
  #
  # def sieve():
  #     spf[1] = 1
  #     for i in range(2, MAXN):
  #         spf[i] = i
  #     for i in range(4, MAXN, 2):
  #         spf[i] = 2
  #
  #     for i in range(3, mt.ceil(mt.sqrt(MAXN))):
  #         if (spf[i] == i):
  #             for j in range(i * i, MAXN, i):
  #                 if (spf[j] == j):
  #                     spf[j] = i
  #
  #
  # def getFactorization(x):
  #     ret = 0
  #     while (x != 1):
  #         k = spf[x]
  #         ret += 1
  #         # ret.add(spf[x])
  #         while x % k == 0:
  #             x //= k
  #
  #     return ret
  
  
  # Driver code
  
  # precalculating Smallest Prime Factor
  # sieve()
  
  def main():
      for _ in range(int(input())):
          n = int(input())
          a = list(map(int, input().split()))
          dp = [[0, 0] for i in range(n + 2)]
          dp[0][0] = 1
          for i in a:
              dp[i + 1][0] += dp[i + 1][0] % mod
              dp[i+1][1]+=dp[i+1][1]%mod
              dp[i + 1][0] += dp[i][0]
              dp[i + 1][0] %= mod
              if i-1>=0:
                  dp[i-1][1]+=(dp[i-1][1]+dp[i-1][0])
                  dp[i-1][1]%=mod
              #print(*dp)
  
          ans = 0
          for i in range(n + 2):
              ans = (ans + dp[i][0]+dp[i][1]) % mod
          #print(dp)
          print((ans-dp[0][0]+mod)%mod)
  
          # = map(int,input().split())
          # s=input()
  
      return
  
  
  if __name__ == "__main__":
      main()
  