#数据输入
n = int(input())
nums = list(map(int, input().split(' ')))
# print(nums) 数据输入无误

#使用单调栈计算美好值总和 ans为美好值总和 s为一个单调递增的栈
ans = 0
s = list()  #使用列表来模拟栈
nums.append(float('-inf'))  #使用一个极小值（负数）来清空栈内可能存在的剩余美好值
for i,item in enumerate(nums):
    while s and nums[s[-1]]>item:   #构造单调递增栈
        tmp = s.pop()
        if s:
            ans += nums[s[-1]]  #计算存在的剩余美好值
    s.append(i)
print(ans)

from collections import deque
import bisect

n = int(input())
nums = list(map(int, input().split()))

queue = deque()
result = 0
for num in nums:
    while queue and num < queue[-1]:
        queue.pop()
    if queue:
        result+= queue[-1]
    queue.append(num)
    pass
print(result)

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, x;
    cin >> n;  // 输入数组的长度
    long long res = 0;  // 用于保存美好值的总和
    stack<int> stk;  // 单调栈，用于存储元素

    // 遍历数组
    for (int i = 0; i < n; i++) {
        cin >> x;  // 输入当前元素
        
        // 保持栈的单调性，弹出栈顶大于当前元素的所有元素
        while (!stk.empty() && stk.top() > x) {
            stk.pop();
        }

        // 如果栈不为空，说明找到了左边第一个小于等于当前元素的值
        if (!stk.empty()) {
            res += stk.top();  // 累加该值到结果中
        }

        // 将当前元素压入栈中
        stk.push(x);
    }

    // 输出美好值的总和
    cout << res << endl;
    return 0;
}

# 输入数组的长度
n = int(input())
# 输入数组元素并转为整数列表
nums = list(map(int, input().split()))
# 反转数组，使得可以使用栈找出左边第一个小于等于当前元素的值
nums.reverse()

# 初始化栈，用于存储索引
stack = []
# 初始化美好值的总和
ans = 0

# 遍历反转后的数组
for i, num in enumerate(nums):
    # 当栈不为空且当前元素小于等于栈顶索引对应的元素时，弹出栈顶
    while len(stack) > 0 and num <= nums[stack[-1]]:
        stack.pop()  # 弹出栈顶元素
        ans += num   # 将当前元素累加到美好值总和中
    
    # 将当前元素的索引压入栈中
    stack.append(i)

# 输出美好值的总和
print(ans)

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 创建输入扫描器
        Scanner in = new Scanner(System.in);
        
        // 读取数组长度
        int n = in.nextInt();
        // 创建数组以存储输入的整数
        int[] a = new int[n];
        
        // 读取数组元素
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
        }
        
        // 初始化美好值的总和
        long res = 0;
        // 使用双端队列作为栈来存储元素
        Deque<Integer> stack = new LinkedList<>();
        
        // 从数组末尾向前遍历
        for (int i = n - 1; i >= 0; i--) {
            // 当栈不为空且当前元素小于等于栈顶元素时，弹出栈顶元素
            while (!stack.isEmpty() && a[i] <= stack.peek()) {
                stack.pop();  // 弹出栈顶元素
                res += a[i];  // 将当前元素累加到美好值总和中
            }
            // 将当前元素压入栈中
            stack.push(a[i]);
        }
        
        // 输出美好值的总和
        System.out.println(res);
    }
}