1000_D. Yet Another Problem On a Subsequence
The sequence of integers a_1, a_2, ..., a_k is called a good array if a_1 = k - 1 and a_1 > 0. For example, the sequences [3, -1, 44, 0], [1, -99] are good arrays, and the sequences [3, 7, 8], [2, 5, 4, 1], [0] — are not.

A sequence of integers is called good if it can be divided into a positive number of good arrays. Each good array should be a subsegment of sequence and each element of the sequence should belong to exactly one array. For example, the sequences [2, -3, 0, 1, 4], [1, 2, 3, -3, -9, 4] are good, and the sequences [2, -3, 0, 1], [1, 2, 3, -3 -9, 4, 1] — are not.

For a given sequence of numbers, count the number of its subsequences that are good sequences, and print the number of such subsequences modulo 998244353.

Input

The first line contains the number n~(1 ≤ n ≤ 10^3) — the length of the initial sequence. The following line contains n integers a_1, a_2, ..., a_n~(-10^9 ≤ a_i ≤ 10^9) — the sequence itself.

Output

In the single line output one integer — the number of subsequences of the original sequence that are good sequences, taken modulo 998244353.

Examples

Input

3
2 1 1


Output

2


Input

4
1 1 1 1


Output

7

Note

In the first test case, two good subsequences — [a_1, a_2, a_3] and [a_2, a_3].

In the second test case, seven good subsequences — [a_1, a_2, a_3, a_4], [a_1, a_2], [a_1, a_3], [a_1, a_4], [a_2, a_3], [a_2, a_4] and [a_3, a_4].
```python
import sys
input=sys.stdin.readline
N=10**4+10
mod=998244353
g1=[1,1]
g2=[1,1]
inv=[0,1]
for i in range(2,N+1):
    g1.append((g1[-1]*i)%mod)
    inv.append((-inv[mod%i]*(mod//i))%mod)
    g2.append((g2[-1]*inv[-1])%mod)
def comb(m,r,mod):
    if r<0 or r>m:
        return 0
    return (g1[m]*g2[r]*g2[m-r])%mod
n=int(input())
a=[0]+list(map(int,input().split()))
dp=[0]*(n+2)
dp[n+1]=1
for i in range(1,n+1)[::-1]:
    if a[i]<=0:
        continue
    for j in range(i+a[i]+1,n+2):
        dp[i]+=dp[j]*comb(j-i-1,a[i],mod)%mod
        dp[i]%=mod
print(sum(dp[:-1])%mod)
```