#!/bin/ruby

class MyTree
    attr_accessor :root
    def initialize(root = nil)
        @root = root
    end
    
    def insert(key, val)
        node = MyTreeNode.new(key, val)
        if @root == nil
            @root = node
        else
            @root.insert(node)
        end
    end
end

class MyTreeNode
    attr_accessor :key,:val,  :left, :right
    def initialize(key, val)
        @key = key
        @val = val
        @left = nil
        @right = nil
    end
    
    def insert(node)
        cur = self
        while true
            if node.key < cur.key
                if cur.left == nil
                    cur.left = node
                    break
               else
                 cur = cur.left
              end
              next
         end
         
          if cur.right == nil
                cur.right = node
             break
         else
                cur = cur.right
             next
         end
        end
    end
end

def forward(a, tree, i, j)
    return 0 if i > j
    stack = [[a, tree, i, j]]
    result = 0
    while !stack.empty?
        a, tree, i, j = stack.pop
        next if i > j
        n = j - i + 1
        it = tree.key
        s = it - i
        l = j - it
        v = n * (n + 1) * (2 * n + 1) / 6
        v -= n * s * (s + 1) / 2 - s * s * (s + 1) / 2 + s * (s + 1) * (2 * s + 1) / 6
        v -= n * l * (l + 1) / 2 - l * l * (l + 1) / 2 + l * (l + 1) * (2 * l + 1) / 6
        result += v * a[it]
        stack.push([a, tree.left, i, it - 1])
        stack.push([a, tree.right, it + 1, j])
    end
    return result
end

def snip_value(n, k)
    if k <= ((n - 2) / 2)
        return k * (k + 1) * (k + 2) / 6
    elsif n % 2 == 1
        p = k - (n - 2) / 2
        return k * (k + 1) * (k + 2) / 6 - p * (p + 1) * (4 * p - 1) / 6
    else
        p = k - (n - 2) / 2
        return k * (k + 1) * (k + 2) / 6 - p * (p + 1) * (4 * p + 5) / 6
    end
end

def snip_intersection(n, k1, k2)
    debug = false
    sz = k1 + k2 - (n - 3)
    return 0 if sz <= 0
    v2 = snip_value(sz * 2 + 3, sz)
    offset = (n - 3 - [k1, k2].max)
    v2 += (sz) * (sz + 1) / 2 * offset
    k = offset + sz
    return v2 if k <= ((n - 2) / 2)
    if n % 2 == 1
        p = k - (n - 2) / 2
        v2 -= p * (p + 1) * (4 * p - 1) / 6
    else
        p = k - (n - 2) / 2
        v2 -= p * (p + 1) * (4 * p + 5) / 6
    end    
    return v2
end

def backward(a, sorted)
    snip_l = snip_r = s = cur_snip_l = cur_snip_r = 0
    n = a.length
    for i in sorted
        break if cur_snip_l == n - 3 || cur_snip_r == n - 3
        if i == 0 || i == 1 || i == n - 1 # full snip!
            cur_snip_l = n - 3
            next if snip_l == cur_snip_l
        else
            cur_snip_l = i - 2
            cur_snip_r = n - i - 2
            next if cur_snip_l <= snip_l && cur_snip_r <= snip_r # Move on if no snip increased
        end
        if snip_l == 0 && snip_r == 0
            # first snip
            s += snip_value(n, cur_snip_l) * a[i]
            s += snip_value(n, cur_snip_r) * a[i]
            snip_l = cur_snip_l
            snip_r = cur_snip_r
            next
        end
        
        if cur_snip_l > snip_l
            # Increasing left snip
            s += snip_value(n, cur_snip_l) * a[i]
            s -= snip_value(n, snip_l) * a[i]
            s -= snip_intersection(n, cur_snip_l, snip_r) * a[i]
            s += snip_intersection(n, snip_l, snip_r) * a[i]
            snip_l = cur_snip_l
            next
        end
        
        # Increasing right snip
        s += snip_value(n, cur_snip_r) * a[i]
        s -= snip_value(n, snip_r) * a[i]
        s -= snip_intersection(n, cur_snip_r, snip_l) * a[i]
        s += snip_intersection(n, snip_l, snip_r) * a[i]
        snip_r = cur_snip_r
    end
    return s
end

def solve(a)    
    boo = []
    for i in (0..a.length - 1)
        boo << [a[i], i]
    end
    
    boo.sort! {|one,two| two[0] <=> one[0]}

 #   p boo
    
    stack = []
    for i in (0..a.length - 1)
        node = MyTreeNode.new(i, a[i])
        while !stack.empty? && stack[-1].val < node.val
            node.left = stack.pop
        end
        if !stack.empty?
            stack[-1].right = node
        end
        stack.push(node)
    end
    node = stack[0]
    
   # p node
    
    r = forward(a, node, 0, a.length - 1)
    r += backward(a, boo.map{|x|x[1]})

    # t measures number of cells from forward phase
    t = 0
    for i in (1..a.length)
        t += i * (i + 1) / 2
    end
    
    # u measures number of cells from backward phase
    u = 0
    for i in (1..(a.length - 2) / 2)
        sp = a.length - 1 - 2 * i
        u += sp * (sp + 1) / 2
    end
    
    b = a.length * (a.length + 1) / 2
    r += a.max * (b * (b + 1) / 2 - t - u)
    return r % (10 ** 9 + 7)
end

n = gets.strip.to_i
a = gets.strip
a = a.split(' ').map(&:to_i)
result = solve(a)
puts result