import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
class SegmentTreeRMQ
{
    int st[]; //array to store segment tree
    int minVal(int x, int y) {
        return (x > y) ? x : y;
    }
    int getMid(int s, int e) {
        return s + (e - s) / 2;
    }
    int RMQUtil(int ss, int se, int qs, int qe, int index)
    {
        if (qs <= ss && qe >= se)
            return st[index];
        if (se < qs || ss > qe)
            return Integer.MIN_VALUE;
        int mid = getMid(ss, se);
        return minVal(RMQUtil(ss, mid, qs, qe, 2 * index + 1),
                RMQUtil(mid + 1, se, qs, qe, 2 * index + 2));
    }
    int RMQ(int n, int qs, int qe)
    {
        if (qs < 0 || qe > n - 1 || qs > qe) {
            System.out.println("Invalid Input");
            return -1;
        }
 
        return RMQUtil(0, n - 1, qs, qe, 0);
    }
    int constructSTUtil(int arr[], int ss, int se, int si)
    {
        if (ss == se) {
            st[si] = arr[ss];
            return arr[ss];
        }
        int mid = getMid(ss, se);
        st[si] = minVal(constructSTUtil(arr, ss, mid, si * 2 + 1),
                constructSTUtil(arr, mid + 1, se, si * 2 + 2));
        return st[si];
    }
    void constructST(int arr[], int n)
    {
        int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
        int max_size = 2 * (int) Math.pow(2, x) - 1;
        st = new int[max_size]; // allocate memory
        constructSTUtil(arr, 0, n - 1, 0);
    }
}
public class Solution {
    static int solve1(ArrayList<Integer> al) {
        //  Return the sum of S(S(A)) modulo 10^9+7.
        SegmentTreeRMQ tree=new SegmentTreeRMQ();
        int mod=1000000007;
        int n=al.size();
        int[] A=new int[n];
        for(int i=0;i<n;i++)
            A[i]=al.get(i);
        tree.constructST(A,n);
        ArrayList<Integer> l=new ArrayList<Integer>();
        int sum1=0;
        for(int k=0;k<n;k++){
            for(int i=0;i<n-k;i++){
                int j=i+k;
                int max=tree.RMQ(n,i,j);
                l.add(max);
                sum1=((sum1%mod)+(max%mod))%mod;
            }
        }
        return sum1%mod;
    }

    static int solve(int[] A) {
        //  Return the sum of S(S(A)) modulo 10^9+7.
        SegmentTreeRMQ tree=new SegmentTreeRMQ();
        int n=A.length;
        tree.constructST(A,n);
        ArrayList<Integer> l=new ArrayList<Integer>();
        for(int k=0;k<n;k++){
            for(int i=0;i<n-k;i++){
                int j=i+k;
                int min=tree.RMQ(n,i,j);
                l.add(min);
            }
        }
        int sum2=solve1(l);
        return sum2;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        for(int a_i = 0; a_i < n; a_i++){
            a[a_i] = in.nextInt();
        }
        int result = solve(a);
        System.out.println(result);
        in.close();
    }
}