#include <bits/stdc++.h>

using namespace std;

const int mod = 1e9 + 7;

const int N = 200005;

int a[N];

inline void add(int &x, int v) {
    x += v;
    if (x >= mod)
        x -= mod;
}

long long f_odd(long long x) {
    long long r = x * x % mod * x % mod * x % mod * 2 % mod;
    r += mod - 4 * x % mod * x % mod * x % mod;
    r += 4 * x % mod * x % mod;
    r += mod - x;
    return r % mod;
}

long long f_even(long long x) {
    long long r = x * x % mod * x % mod * x % mod * 2 % mod;
    r += x * x % mod;
    r += x;
    return r % mod;
}

int pre[N], suf[N], presum[N], ps[N];

int binary(int l, int r, int v) {
    int ret = r + 1;
    while (l <= r) {
        int m = (l + r) >> 1;
        if (pre[m] > v) {
            ret = m;
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    return ret;
}

int L[N], R[N];

stack <int> st;

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
        scanf("%d", a + i);
    for (int i = 0; i < n; ++i) {
        pre[i] = a[i];
        if (i)
            pre[i] = max(pre[i], pre[i - 1]);
        presum[i] = 1ll * i * pre[i] % mod;
        ps[i] = pre[i];
        if (i) {
            add(presum[i], presum[i - 1]);
            add(ps[i], ps[i - 1]);
        }
    }
    for (int i = n - 1; i >= 0; --i) {
        suf[i] = a[i];
        if (i + 1 < n)
            suf[i] = max(suf[i], suf[i + 1]);
    }
    int ans = 0;
    for (int i = 3; i < n; ++i) {
        int len = n - i;
        int mx = suf[i];
        int p = binary(0, i - 2, mx);
        if (0 <= p - 1) {
            if (p - 1 <= len)
                add(ans, 1ll * p * (p - 1) / 2 % mod * mx % mod);
            else {
                add(ans, 1ll * len * (len + 1) / 2 % mod * mx % mod);
                add(ans, 1ll * mx * (p - 1 - len) % mod * len % mod);
            }
        }
        if (p <= i - 2) {
            if (len >= i - 2) {
                add(ans, presum[i - 2]);
                if (p)
                    add(ans, mod - presum[p - 1]);
            } else if (len < p) {
                long long s = ps[i - 2];
                if (p)
                    s = (s + mod - ps[p - 1]) % mod;
                add(ans, s * len % mod);
            } else {
                if (p <= len - 1) {
                    add(ans, presum[len - 1]);
                    if (p)
                        add(ans, mod - presum[p - 1]);
                }
                if (len <= i - 2) {
                    long long s = ps[i - 2];
                    s = (s + mod - ps[len - 1]) % mod;
                    add(ans, s * len % mod);
                }
            }
        }
    }
    for (int i = 0; i < n; ++i) {
        while (st.size() && a[st.top()] < a[i])
            st.pop();
        L[i] = st.size() ? st.top() : -1;
        st.push(i);
    }
    while (st.size())
        st.pop();
    for (int i = n - 1; i >= 0; --i) {
        while (st.size() && a[st.top()] <= a[i])
            st.pop();
        R[i] = st.size() ? st.top() : n;
        st.push(i);
    }
    for (int i = 0; i < n; ++i) {
        int l = L[i] + 1;
        int r = R[i] - 1;
        int b = r - i + 1;
        int k = i - l + 1;
        long long v = (1ll + b) * b / 2 % mod;
        v = v * k % mod;
        v += (k - 1ll) * k / 2 % mod * b % mod;
        v %= mod;
        add(ans, v * a[i] % mod);
    }
    if (n & 1)
        add(ans, pre[n - 1] * f_odd((n + 1) / 2) % mod);
    else
        add(ans, pre[n - 1] * f_even(n / 2) % mod);
    add(ans, mod - 1ll * n * pre[n - 1] % mod);
    printf("%d\n", ans);
    return 0;
}