One day, little Vasya found himself in a maze consisting of (*n* + 1) rooms, numbered from 1 to (*n* + 1). Initially, Vasya is at the first room and to get out of the maze, he needs to get to the (*n* + 1)-th one.

The maze is organized as follows. Each room of the maze has two one-way portals. Let's consider room number *i* (1 ≤ *i* ≤ *n*), someone can use the first portal to move from it to room number (*i* + 1), also someone can use the second portal to move from it to room number *p*<sub class="lower-index">*i*</sub>, where 1 ≤ *p*<sub class="lower-index">*i*</sub> ≤ *i*.

In order not to get lost, Vasya decided to act as follows. 
 -  Each time Vasya enters some room, he paints a cross on its ceiling. Initially, Vasya paints a cross at the ceiling of room 1. -  Let's assume that Vasya is in room *i* and has already painted a cross on its ceiling. Then, if the ceiling now contains an odd number of crosses, Vasya uses the second portal (it leads to room *p*<sub class="lower-index">*i*</sub>), otherwise Vasya uses the first portal. 
Help Vasya determine the number of times he needs to use portals to get to room (*n* + 1) in the end.
The first line contains integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">3</sup>) — the number of rooms. The second line contains *n* integers *p*<sub class="lower-index">*i*</sub> (1 ≤ *p*<sub class="lower-index">*i*</sub> ≤ *i*). Each *p*<sub class="lower-index">*i*</sub> denotes the number of the room, that someone can reach, if he will use the second portal in the *i*-th room.
n = int(input())
A = [int(i) for i in input().split()]

dp = [[[10**10 for i in range(n+1)] for j in range(2)] for k in range(n+1)]

import sys

sys.setrecursionlimit(10**7)

for i in range(n+1):
    for j in range(2):
        dp[i][j][i] = 1

MOD = 10**9 + 7

def f(i, j, x):
    
    if dp[i][j][x] != 10**10:
        return dp[i][j][x]
    if i==x:
        return 1
    else:
        if j==0:
            dp[i][j][x] = (1 + f(i+1, 1, x))%MOD
        else:
            dp[i][j][x] = (1 + (f(A[i]-1, 1, i))%MOD + (f(i+1, 1, x))%MOD)%MOD

        dp[i][j][x] %= MOD

        return dp[i][j][x]

print((f(0, 1, n) - 1)%MOD)


