#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define SZ(a) ((int)a.size())
#define ALL(v) v.begin(), v.end()
#define pb push_back

constexpr int kN = 10010;
constexpr ll kInf = 1e18;

constexpr int kPool = 101;
ll pool[kPool][101][101]; // [][k1][k2];
struct {
    int m, k1; // k2 = k_divide_l - k1;
} pi_pool[kPool][101][101];


vector<pii> ans;
void solve(const ll *s, const int n, const int l1, const int l2, int k1, int k2, int pre_n) {
    if (n == 0) return;
    if (k1 + k2 == 0) return;
    // cerr << "call " << n << ' ' << k1 << ' ' << k2 << endl;
    if (k1 == 1 && k2 == 0) {
        assert(l1 <= n);
        int opt = l1;
        for (int i = l1; i <= n; ++i) {
            if (s[i] - s[i - l1] > s[opt] - s[opt - l1]) {
                opt = i;
            }
        }
        ans.emplace_back(pre_n + opt - l1, pre_n + opt);
        return;
    }
    if (k1 == 0 && k2 == 1) {
        assert(l2 <= n);
        int opt = l2;
        for (int i = l2; i <= n; ++i) {
            if (s[i] - s[i - l2] > s[opt] - s[opt - l2]) {
                opt = i;
            }
        }
        ans.emplace_back(pre_n + opt - l2, pre_n + opt);
        return;
    }
    for (int i = 0; i <= k1; ++i) {
        for (int j = 0; j <= k2; ++j) {
            pool[0][i][j] = -kInf;
            pi_pool[0][i][j].m = -1; // invalid
        }
    }
    pool[0][0][0] = 0;

    const int k_divide = (k1 + k2) / 2;
    for (int m = 1; m <= n; ++m) {
        auto dp = pool[m % kPool], dp_prev = pool[(m + kPool - 1) % kPool];
        auto pi = pi_pool[m % kPool], pi_prev = pi_pool[(m + kPool - 1) % kPool];
        for (int i = 0; i <= k1; ++i) {
            for (int j = 0; j <= k2; ++j) {
                dp[i][j] = dp_prev[i][j];
                pi[i][j] = pi_prev[i][j];
            }
        }

        if (m >= l1) {
            auto dp_src = pool[(m - l1) % kPool];
            auto pi_src = pi_pool[(m - l1) % kPool];
            const ll w = s[m] - s[m - l1];
            for (int i = 1; i <= k1; ++i) {
                for (int j = 0; j <= k2; ++j) {
                    ll v = dp_src[i - 1][j] + w;
                    if (v > dp[i][j]) {
                        dp[i][j] = v;
                        pi[i][j] = pi_src[i - 1][j];
                    }
                }
            }
        }

        if (m >= l2) {
            auto dp_src = pool[(m - l2) % kPool];
            auto pi_src = pi_pool[(m - l2) % kPool];
            const ll w = s[m] - s[m - l2];
            for (int i = 0; i <= k1; ++i) {
                for (int j = 1; j <= k2; ++j) {
                    ll v = dp_src[i][j - 1] + w;
                    if (v > dp[i][j]) {
                        dp[i][j] = v;
                        pi[i][j] = pi_src[i][j - 1];
                    }
                }
            }
        }
        for (int i = 0; i <= k1; ++i) {
            int j = k_divide - i;
            if (j < 0 || j > k2) continue;
            pi[i][j].m = m;
            pi[i][j].k1 = i;
        }
    }
    auto pi = pi_pool[n % kPool][k1][k2];
    int break_k2 = k_divide - pi.k1;
    /*
    cerr << "div at " << pi.m;
    cerr << " k1 = " << pi.k1 << '/' << k1 - pi.k1 << ' ';
    cerr << " k2 = " << break_k2 << '/' << k2 - break_k2 << ' ';
    cerr << endl;
    */
    solve(s, pi.m, l1, l2, pi.k1, break_k2, pre_n);
    solve(s + pi.m, n - pi.m, l1, l2, k1 - pi.k1, k2 - break_k2, pre_n + pi.m);
}


int a[kN];
ll s[kN];

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int n, k1, l1, k2, l2;
    cin >> n >> k1 >> l1 >> k2 >> l2;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        s[i] = s[i - 1] + a[i];
    }
    solve(s, n, l1, l2, k1, k2, 0);
    ll c = 0;
    for (auto &p : ans) c = c + s[p.second] - s[p.first];
    cout << c << '\n';
    for (auto &p : ans) cout << p.first << ' ' << p.second << '\n';
}