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

#define rep(i, N) for (int i = 0; i < (N); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back

using ll = long long;
using i_i = tuple<int, int>;

random_device rd;
mt19937 mt = mt19937(rd());

bool chmin(int& x, int y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}

bool chmax(int& x, int y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}

vector<int> solve(vector<int> x, int K) {
    int N = x.size();
    int W = 0, W_K = 0;
    rep(i, N) W += x[i];
    rep(i, K) W_K += x[i];
    vector<int> dp0(W + 1, K + 1), dp1(W + 1, K + 1);
    vector<int> t(W + 1, N + 1);
    dp0[W_K] = 0;
    t[W_K] = K;
    for (int i = K; i < N; i++) {
        vector<int> _dp0 = dp0;
        rep(w0, W + 1) if (dp0[w0] < K + 1) {
            int w1 = w0 + x[i];
            for (int j = dp0[w0]; j < min(K, dp1[w1]); j++) {
                int _w0 = w1 - x[j];
                chmin(_dp0[_w0], j + 1);
            }
            chmin(dp1[w1], dp0[w0]);
        }
        dp0 = _dp0;
        rep(w0, W + 1) if (dp0[w0] < K + 1) chmin(t[w0], i + 1);
    }
    return t;
}

vector<bool> fukugen(vector<int> x, int K, int w_target) {
    int N = x.size();
    if (K == 1) {
        vector<bool> ans(N);
        rep(i, N) if (x[i] == w_target) {
            ans[i] = true;
            break;
        }
        return ans;
    }
    vector<int> p(N);
    rep(i, N) p[i] = i;
    shuffle(all(p), mt);
    vector<int> x1(N), x2(N);
    rep(i, N) x1[i] = x2[N - 1 - i] = x[p[i]];
    int K1 = K / 2, K2 = K - K1;
    vector<int> t1 = solve(x1, K1);
    vector<int> t2 = solve(x2, K2);
    int time_opt = -1, w1_opt;
    rep(w1, w_target + 1) {
        int w2 = w_target - w1;
        if (t1[w1] + t2[w2] <= N) {
            int time = t1[w1] * w1 + t2[w2] * w2;
            if (chmax(time_opt, time)) w1_opt = w1;
        }
    }
    int w2_opt = w_target - w1_opt;
    int N1 = t1[w1_opt], N2 = t2[w2_opt];
    x1.resize(N1);
    x2.resize(N2);
    vector<bool> sol1 = fukugen(x1, K1, w1_opt);
    vector<bool> sol2 = fukugen(x2, K2, w2_opt);
    vector<bool> sol(N);
    rep(i1, N1) sol[p[i1]] = sol1[i1];
    rep(i2, N2) sol[p[N - 1 - i2]] = sol2[i2];
    return sol;
}

int main() {
    int N, K, a, b;
    cin >> N >> K >> a >> b;
    vector<int> x(N);
    rep(i, N) cin >> x[i];
    vector<int> t = solve(x, K);
    int W = t.size() - 1;
    set<int> pos;
    rep(w, W + 1) if (t[w] < N + 1) pos.insert(w);
    int ma = -1, alice, bob;
    for (int w = a; w <= b; w++) {
        int mi = INT_MAX / 2, w_mi;
        auto it = pos.lower_bound(w);
        if (it != pos.end()) if (chmin(mi, abs(*it - w))) w_mi = *it;
        if (it != pos.begin()) if (chmin(mi, abs(*prev(it) - w))) w_mi = *prev(it);
        if (chmax(ma, mi)) {
            alice = w;
            bob = w_mi;
        }
    }
    vector<bool> ans = fukugen(x, K, bob);
    cout << alice << endl;
    cerr << bob << endl;
    rep(i, N) if (ans[i]) cout << i + 1 << ' ';
    cout << endl;
}