Squirrel Liss loves nuts. There are *n* trees (numbered 1 to *n* from west to east) along a street and there is a delicious nut on the top of each tree. The height of the tree *i* is *h*<sub class="lower-index">*i*</sub>. Liss wants to eat all nuts.

Now Liss is on the root of the tree with the number 1. In one second Liss can perform one of the following actions:
 -  Walk up or down one unit on a tree. -  Eat a nut on the top of the current tree. -  Jump to the next tree. In this action the height of Liss doesn't change. More formally, when Liss is at height *h* of the tree *i* (1 ≤ *i* ≤ *n* - 1), she jumps to height *h* of the tree *i* + 1. This action can't be performed if *h* &gt; *h*<sub class="lower-index">*i* + 1</sub>. 
Compute the minimal time (in seconds) required to eat all nuts.
The first line contains an integer *n* (1  ≤  *n* ≤ 10<sup class="upper-index">5</sup>) — the number of trees.

Next *n* lines contains the height of trees: *i*-th line contains an integer *h*<sub class="lower-index">*i*</sub> (1 ≤ *h*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">4</sup>) — the height of the tree with the number *i*.
import com.sun.jdi.ArrayReference;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        FastScanner fs = new FastScanner();

        int n = fs.nextInt();
        int[] a = fs.readArray(n);
        int ans = a[n-1] + n;
        for (int i = n-1; i>0; i--) {
            if (a[i] >= a[i-1]) {
                ans += 1;
            } else {
                ans += a[i];
                ans += a[i-1];
            }
        }
        System.out.println(ans);



    }
    public static boolean inArray(ArrayList<Integer> a, int n) {
        for (int i = 0; i<a.size(); i++) {
            if (a.get(i) == n) return true;
        }
        return false;
    }


    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

}

