#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using vi = vector <int>;

const int MAX_N = 100000 + 5;
const int MAX_M = 200 + 5;
const ll INF64 = 1e18;

int N, a[MAX_N], rnk[MAX_N], ql, qr, c[MAX_N];
int ls[MAX_N], rs[MAX_N];
ll f[MAX_M][MAX_M], ans;

void modify(int x, int v) {
    for (int i = x; i <= N; i += i & -i) c[i] += v;
}

int query(int l, int r) {
    l --;
    int res = 0;
    while (l < r) {
        res += c[r];
        r -= r & -r;
    }
    while (r < l) {
        res -= c[l];
        l -= l & -l;
    }
    return res;
}

void dfs2(int u, vi &node) {
    if (!u) return ;
    node.push_back(rnk[u]);
    dfs2(ls[u], node);
    dfs2(rs[u], node);
}

ll calc(const vi &A) {
    static int b[MAX_N];
    int m = 0;
    for (auto x : A) b[++ m] = x;
    sort(b + 1, b + m + 1);
    int n = A.size();
    static int rnk[MAX_N], st[MAX_N], ch[MAX_N][2];
    for (int i = 1; i <= n; i ++) {
        rnk[lower_bound(b + 1, b + m + 1, A[i - 1]) - b] = i;
    }
    int top = 0;
    for (int i = 1; i <= n; ++ i){
        while(top && rnk[st[top]] > rnk[i]) ch[i][0] = st[top], -- top;
        ch[st[top]][1] = i;
        st[++ top] = i;
    }
    queue <pair <int, int>> q;
    q.push(pair(st[1], 0));
    ll res = 0;
    while (!q.empty()) {
        auto [u, d] = q.front();
        q.pop();
        res += d;
        if (ch[u][0]) q.push(pair(ch[u][0], d + 1));
        if (ch[u][1]) q.push(pair(ch[u][1], d + 1));
    }
    return res;
}

void dp(const vi &node, int L, int R) {
    vi b(0), tmp(0);
    for (auto x : node) {
        assert(x >= ql);
        if (x <= qr) b.push_back(x);
        else tmp.push_back(x);
        modify(a[x], 1);
    }
    auto cmp_by_a = [&](int i, int j) -> bool {
        return a[i] < a[j];
    };
    sort(b.begin(), b.end(), cmp_by_a);
    sort(tmp.begin(), tmp.end(), cmp_by_a);
    int M = b.size();
    static int lw[MAX_M], rw[MAX_M];
    for (int i = 0; i < M; i ++) {
        if (i > 0) lw[i] = a[b[i - 1]] + 1;
        else lw[i] = L;
        if (i == M - 1) rw[i] = R;
        else rw[i] = a[b[i + 1]] - 1;
        for (int j = i; j < M; j ++) {
            f[i][j] = INF64;
        }
    }
    static ll cost[MAX_M];
    vi name;
    for (int i = 0, j = 0; i < M; i ++) {
        name.clear();
        for ( ; j < (int)tmp.size() && a[tmp[j]] < a[b[i]]; j ++) name.push_back(a[tmp[j]]);
        cost[i] = calc(name);
    }
    name.clear();
    for (auto x : tmp) {
        if (a[x] > a[b.back()]) name.push_back(a[x]);
    }
    cost[M] = calc(name);
    for (int i = 1; i <= M; i ++) {
        for (int j = 0; j + i - 1 < M; j ++) {
            int l = j, r = j + i - 1;
            for (int k = l; k <= r; k ++) {
                f[l][r] = min(f[l][r], f[l][k - 1] + f[k + 1][r] + query(lw[l], rw[r]) - 1 + cost[l] + cost[r + 1]);
            }
        }
    }
    ans += f[0][M - 1];
    for (auto x : node) modify(a[x], -1);
}

void dfs(int u, int dep, int L = 1, int R = N) {
    if (ql <= rnk[u] && rnk[u] <= qr) {
        vi node(0);
        dfs2(u, node);
        ans += 1ll * dep * node.size();
        dp(node, L, R);
        return ;
    }
    ans += dep;
    if (ls[u]) dfs(ls[u], dep + 1, L, u - 1);
    if (rs[u]) dfs(rs[u], dep + 1, u + 1, R);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    
    cin >> N;
    for (int i = 1; i <= N; ++ i) cin >> a[i], rnk[a[i]] = i;
    int top = 0; static int st[MAX_N], fa[MAX_N];
     for (int i = 1; i <= N; ++ i){
        while(top && rnk[st[top]] > rnk[i]) ls[i] = st[top], -- top;
        rs[st[top]] = i;
        st[++ top] = i;
    }
    cin >> ql >> qr;
    dfs(st[1], 1);
    cout << ans << endl;
    
    return 0;
}