#include <bits/stdc++.h>

using namespace std;

constexpr unsigned mod = 1000000007;
int solve(vector<int> data) {
    using ul = __int128;
    const ul size = data.size();
    const ul size1 = size*(size+1)/2;
    const ul size2 = size1*(size1+1)/2;

    const auto maxi = *max_element(data.begin(), data.end());
    ul ret = size2*maxi;

    vector<pair<int, pair<ul, ul>>> stack; // val idx prev_num
    for (unsigned i = 0; i <= data.size(); ++i) {
        int d = i == data.size() ? maxi : data[i];
        unsigned idx = i;
        ul corr = 0;
        while (!stack.empty() && d > stack.back().first) {
            int val = stack.back().first;
            tie(idx, corr) = stack.back().second;
            stack.pop_back();

            const ul len = i - idx;
            const ul num = (len*(len+1)*(len+2)/6);
            const ul full_num = (num - corr);
            const ul sub = ul(full_num)*(maxi - val);
            ret = (ret - sub);
            corr = num;
            if (!stack.empty() && stack.back().first <= d) {
                stack.back().second.second += corr;
                corr = 0;
            }
        }
        if (!stack.empty() && d == stack.back().first)
        {}
        else
            if (d < maxi)
                stack.push_back({d, {idx, corr}});
    }

    vector<int> lstack, rstack;
    for (auto it = data.rbegin(); *it != maxi; ++it)
        lstack.emplace_back(lstack.empty() ? *it : max(lstack.back(), *it));
    for (unsigned i = 1; i < data.size(); ++i)
        data[i-1] = max(data[i-1], data[i]);

    for (auto it = data.begin(); *it != maxi; ++it)
        rstack.emplace_back(rstack.empty() ? *it : max(rstack.back(), *it));

    while(!lstack.empty() && !rstack.empty()) {
        auto& main = lstack.back() >= rstack.back() ? lstack : rstack;
        auto& other = lstack.back() >= rstack.back() ? rstack : lstack;

        const ul diff = other.size() > main.size() ? other.size() - main.size() : 0;
        const ul other_num = other.size()*(other.size()+1)/2;
        const ul diff_num = diff*(diff+1)/2;
        ul num = (other_num - diff_num );
        ul sub = ul(maxi - main.back())*num;
        ret = (ret - sub);
        main.pop_back();
    }
    return ret % mod;
}

int main() {
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    vector<int> a(n);
    for(int a_i = 0; a_i < n; a_i++)
        cin >> a[a_i];
    cout << solve(move(a)) << endl;
    return 0;
}