#include <bits/stdc++.h>

using namespace std;

template <class T>
inline void hash_combine(std::size_t & seed, const T & v)
{
  std::hash<T> hasher;
  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
 
namespace std
{
  template<typename S, typename T> struct hash<pair<S, T>>
  {
    inline size_t operator()(const pair<S, T> & v) const
    {
      size_t seed = 0;
      ::hash_combine(seed, v.first);
      ::hash_combine(seed, v.second);
      return seed;
    }
  };
}

bool desc(pair<int, int> A, pair<int, int> B) {
    return A.first > B.first;
}

void get_range(int &lo, int &hi, int i, int k, int sn, int n) {
    int x = sn - i;
    int r = ceil((-1 + sqrt(1 + 8 * x)) / 2);
    int beg = sn - ((r * (r + 1)) / 2);
    int k2 = n - r;
    lo = i - beg;
    int hi1 = lo + k2;
    int lo2 = hi1 + k - n;
    int hi2 = lo2 + (k2 + 1);
    if (k + lo >= r) { // if k is large enough to move to next range
        if (hi2 >= lo - 1)   // if k is large enough to encompass the entire array
            hi = (lo == 0) ? n - 1 : lo - 1;
        else hi = hi2;
    }
    else hi = hi1 + k;
}

int solve(vector<int> A) {
    //  Return the sum of S(S(A)) modulo 10^9+7.    
    
    int n = A.size();           // A    size
    if (n == 1)
        return A[0];
    
    int mod = 1000000007;
    int sum = 0;
    int sn = (n * (n + 1)) / 2; // S(A) size
    
    vector<pair<int, int>> B(n);
    for (int i = 0; i < n; ++i) {
        B[i].first = A[i];
        B[i].second = i;
    }
    sort(B.begin(), B.end(), desc);
    int max_val[n][n];
    int m = B[0].second;
    
    unordered_set<pair<int, int>> todo;
    
    for (int beg = 0; beg < n; ++beg) {
        for (int end = 0; end < n; ++end) {
            if ((beg <= end && beg <= m && m <= end) || (beg > end && (beg <= m || m <= end)))
                max_val[beg][end] = m;
            else todo.insert(make_pair(beg, end));
        }
    }

    
    for (auto it = B.begin() + 1; it != B.end(); ++it) {
        m = it->second;
        vector<pair<int, int>> to_remove;
        for (auto coord = todo.begin(); coord != todo.end(); ++coord) {
            int beg = coord->first;
            int end = coord->second;
            if ((beg <= end && beg <= m && m <= end) || (beg > end && (beg <= m || m <= end))) {
                    max_val[beg][end] = m;
                    to_remove.push_back(make_pair(beg, end));
            }
        }
        for (auto remit = to_remove.begin(); remit != to_remove.end(); ++remit)
            todo.erase(*remit);
    }
    
    for (int k = 0; k < sn; ++k) {           // Perform max transform twice
        for (int i = 0; i < sn - k; ++i) {
            int hi, lo;
            get_range(lo, hi, i, k, sn, n);
            //cout << A[max_val[lo][hi]] << ' ';
            sum = ((long long)sum + A[max_val[lo][hi]]) % mod;
        }
    }

    return sum;
}

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