#include <cassert>
#include <vector>
#include <iostream>
#include <algorithm>
#include <set>

using namespace std;

const long long mod = 1e9 + 7ll;
const long long inv2 = mod / 2 + 1;
const long long inv6 = mod / 6 + 1;
static_assert((2 * inv2) % mod == 1);
static_assert((6 * inv6) % mod == 1);

const int N = 200010;
long long ssum2[N];

long long sum2(long long x) {
    long long ans = x;
    ans = (ans * (x+1)) % mod;
    ans = (ans * inv2) % mod;
    return ans;
}
long long sumsq(long long x) {
    long long ans = x;
    ans = (ans * (x+1)) % mod;
    ans = (ans * (2*x+1)) % mod;
    ans = (ans * inv6) % mod;
    return ans;
}
long long calculate(int a, int x, int b, int aa, int bb, int n) {
    
    assert(a != -1 || b != n);
    
    long long ans = 0ll;
    int len = b - a - 1;
    int pos = x - a;
    
    ans = ssum2[len];
    ans = (ans - ssum2[pos-1]) % mod;
    ans = (ans - ssum2[len-pos]) % mod;
    
    if (a == -1) {
        int llen = n-bb-1;
        /*
        for (int k = 2; k <= len and k-1 <= llen; ++k) {
            long long nlen = len-k+1;
            long long npos1 = max(1, pos-k+1);
            ans = (ans + (nlen-npos1+1) * (llen-(k-1)+1)) % mod;
        }
        */
        
        // use pos-k+1: pos-k+1 >= 1 # k <= pos
        // ans = (ans + (len-pos+1) * (llen-k+2)) % mod;
        int lim = min(pos, min(len, llen+1));
        if (lim >= 2) {
            ans = (ans + (sum2(llen) - sum2(llen-lim+1)) * (len-pos+1)) % mod;
        }
        
        // use 1: pos-k+1 < 1 # k > pos
        int a = pos+1, b = min(len, llen+1);
        if (a <= b) {
            ans = (ans + (long long) (b-a+1) * (len+1) * (llen+2)) % mod;
            ans = (ans - (sum2(b) - sum2(a-1)) * (len+llen+3)) % mod;
            ans = (ans + (sumsq(b) - sumsq(a-1))) % mod;
        }

    }
    
    if (b == n) {
        int llen = aa;
        /*
        for (int k = 1; k <= len and k+1 <= llen; ++k) {
            int nlen = len-k+1;
            long long npos2 = min(nlen, pos);
            ans = (ans + npos2 * (llen-(k+1)+1)) % mod;
        } 
        */
        
        // use pos : nlen > pos # len-k+1 > pos # k < len+1-pos
        ans = (ans + pos * (sum2(llen-1) - sum2(max(0, llen-min(llen-1, len-pos)-1)))) % mod;

        // use nlen : nlen <= pos # len-k+1 <= pos # k >= len+1-pos
        int a = len-pos+1, b = min(len, llen-1);
        if (a <= b) {
            ans = (ans + (long long) (b-a+1) * len * llen) % mod;
            ans = (ans - (sum2(b-1) - sum2(a-2)) * llen) % mod;
            ans = (ans - (sum2(b) - sum2(a-1)) * len) % mod;
            ans = (ans + (sumsq(b) - sumsq(a-1)) - (sum2(b) - sum2(a-1))) % mod;
        }
    }
    
    return ans;
}

int main() {
        
    int n;
    cin >> n;
  
    vector<long long> A(n);
    for (long long &val : A) {
        cin >> val;
    }
    
    ssum2[0] = 0;
    for (int i = 1; i <= n; ++i) {
        ssum2[i] = (ssum2[i-1] + sum2(i)) % mod;
    }
    
    vector<int> indices(n);
    for (int i = 0; i < n; ++i) {
        indices[i] = i;
    }

    sort(indices.begin(), indices.end(), [&A] (int i, int j) {
        return A[i] < A[j];
    });
    
    set<int> S(indices.begin(), indices.end());
    long long total = sum2(sum2(n));
    long long ans = 0ll;
    for (int idx : indices) {
        S.erase(idx);
        auto it = S.lower_bound(idx);
        int left = (it != S.begin() ? *prev(it) : -1);
        int right = (it != S.end() ? *it : n);
        
        if (S.empty()) {
            assert(left == -1 and right == n);
            ans = (ans + A[idx] * total) % mod;
        } else {
            
            int left_most = *S.begin();
            int right_most = *prev(S.end());
            
            long long num = calculate(left, idx, right, left_most, right_most, n) % mod;
            ans = (ans + A[idx] * num) % mod;
            total = (total - num) % mod;
        }
    }
    
    ans = (ans % mod + mod) % mod;
    
    cout << ans << endl;
    
    return 0;
}