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.
from __future__ import division, print_function
 
from types import GeneratorType
 
def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
 
    return wrappedfunc
####################################################
from collections import defaultdict
n=int(input())
l=list(map(int,input().split()))
l1=[[0,0] for i in range(n)]
ans=0
d=defaultdict(int)
m=10**9+7
@bootstrap
def f(x):
    global n,ans,m
    d[x]+=1
    if d[x]==2 and x!=n:
        l1[x][1]=ans
    if d[x]==1 and x!=n:
        l1[x][0]=ans
    #print(x,ans,d[2])
    if x==n:
        return
    if d[x]>2:
        if d[x]%2:
            ans+=l1[x][1]-l1[x][0]+1
            ans%=m
            d[x]+=1
            f(x+1)
        else:
            ans+=1
            ans%=m
            f(x+1)
    else:
        if d[x]%2:
            if d[l[x]-1]>1 and d[l[x]-1]%2==0:
                d[l[x]-1]+=2
                ans+=l1[l[x]-1][1]-l1[l[x]-1][0]+2
                ans%=m
                f(l[x])
            elif d[l[x]-1]>1 and d[l[x]-1]%2:
                d[l[x]-1]+=1
                ans+=2
                ans%=m
                f(l[x])
            else:
                ans+=1
                ans%=m
                f(l[x]-1)
        else:
            ans+=1
            ans%=m
            f(x+1)
    return
f(0)
print(ans)

