#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Service {
    int id;
    int power;
    int value;
};

struct State {
    long long value = 0;
    int power = 0;
    int count = 0;

    // 比较函数，判断 newState 是否比当前 state 更优
    bool is_better_than(const State& other) const {
        if (value > other.value) return true;
        if (value == other.value) {
            if (power < other.power) return true;
            if (power == other.power) {
                if (count < other.count) return true;
            }
        }
        return false;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    cin >> n;
    int c;
    cin >> c;

    vector<Service> services(n);
    for (int i = 0; i < n; ++i) {
        services[i].id = i + 1;
        cin >> services[i].power >> services[i].value;
    }

    vector<vector<State>> dp(n + 1, vector<State>(c + 1));

    for (int i = 1; i <= n; ++i) {
        int p = services[i - 1].power;
        int v = services[i - 1].value;

        for (int j = 0; j <= c; ++j) {
            // 默认不选第i个服务
            dp[i][j] = dp[i - 1][j];

            // 尝试选择第i个服务
            if (j >= p) {
                State prev_state = dp[i - 1][j - p];
                State new_state;
                new_state.value = prev_state.value + v;
                new_state.power = prev_state.power + p;
                new_state.count = prev_state.count + 1;

                if (new_state.is_better_than(dp[i][j])) {
                    dp[i][j] = new_state;
                }
            }
        }
    }

    // 在所有可能的总功耗中找到最优解
    State best_state = dp[n][0];
    int final_power = 0;
    for (int j = 1; j <= c; ++j) {
        if (dp[n][j].is_better_than(best_state)) {
            best_state = dp[n][j];
            final_power = j;
        }
    }

    if (best_state.value == 0) {
        cout << -1 << endl;
        return 0;
    }

    // 回溯找到选择的服务
    vector<int> result_ids;
    int current_power = final_power;
    for (int i = n; i > 0 && current_power > 0; --i) {
        // 比较状态对象需要比较所有成员
        bool is_equal = (dp[i][current_power].value == dp[i - 1][current_power].value &&
                         dp[i][current_power].power == dp[i - 1][current_power].power &&
                         dp[i][current_power].count == dp[i - 1][current_power].count);

        if (!is_equal) {
            result_ids.push_back(services[i - 1].id);
            current_power -= services[i - 1].power;
        }
    }

    sort(result_ids.begin(), result_ids.end());

    for (size_t i = 0; i < result_ids.size(); ++i) {
        cout << result_ids[i] << (i == result_ids.size() - 1 ? "" : " ");
    }
    cout << endl;

    return 0;
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

class Service {
    int id;
    int power;
    int value;

    public Service(int id, int power, int value) {
        this.id = id;
        this.power = power;
        this.value = value;
    }
}

class State {
    long value = 0;
    int power = 0;
    int count = 0;

    // 复制构造函数
    public State(State other) {
        this.value = other.value;
        this.power = other.power;
        this.count = other.count;
    }
    
    public State() {}

    // 判断 this 是否比 other 更优
    public boolean isBetterThan(State other) {
        if (this.value > other.value) return true;
        if (this.value == other.value) {
            if (this.power < other.power) return true;
            if (this.power == other.power) {
                if (this.count < other.count) return true;
            }
        }
        return false;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        State state = (State) obj;
        return value == state.value && power == state.power && count == state.count;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int c = sc.nextInt();

        Service[] services = new Service[n];
        for (int i = 0; i < n; i++) {
            services[i] = new Service(i + 1, sc.nextInt(), sc.nextInt());
        }

        State[][] dp = new State[n + 1][c + 1];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= c; j++) {
                dp[i][j] = new State();
            }
        }

        for (int i = 1; i <= n; i++) {
            int p = services[i - 1].power;
            int v = services[i - 1].value;

            for (int j = 0; j <= c; j++) {
                // 不选第i个服务
                dp[i][j] = new State(dp[i - 1][j]);

                // 尝试选第i个服务
                if (j >= p) {
                    State prevState = dp[i - 1][j - p];
                    State newState = new State();
                    newState.value = prevState.value + v;
                    newState.power = prevState.power + p;
                    newState.count = prevState.count + 1;

                    if (newState.isBetterThan(dp[i][j])) {
                        dp[i][j] = newState;
                    }
                }
            }
        }

        State bestState = dp[n][0];
        int finalPower = 0;
        for (int j = 1; j <= c; j++) {
            if (dp[n][j].isBetterThan(bestState)) {
                bestState = dp[n][j];
                finalPower = j;
            }
        }

        if (bestState.value == 0) {
            System.out.println(-1);
            return;
        }

        List<Integer> resultIds = new ArrayList<>();
        int currentPower = finalPower;
        for (int i = n; i > 0 && currentPower > 0; i--) {
            if (!dp[i][currentPower].equals(dp[i - 1][currentPower])) {
                resultIds.add(services[i - 1].id);
                currentPower -= services[i - 1].power;
            }
        }

        Collections.sort(resultIds);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < resultIds.size(); i++) {
            sb.append(resultIds.get(i));
            if (i < resultIds.size() - 1) {
                sb.append(" ");
            }
        }
        System.out.println(sb.toString());
    }
}

import sys

class State:
    def __init__(self, value=0, power=0, count=0):
        self.value = value
        self.power = power
        self.count = count

def is_better(s1, s2):
    """判断 s1 是否比 s2 更优"""
    if s1.value > s2.value:
        return True
    if s1.value == s2.value:
        if s1.power < s2.power:
            return True
        if s1.power == s2.power:
            if s1.count < s2.count:
                return True
    return False

def is_equal(s1, s2):
    return s1.value == s2.value and s1.power == s2.power and s1.count == s2.count

def solve():
    lines = sys.stdin.readlines()
    if not lines:
        return

    n = int(lines[0])
    c = int(lines[1])
    services = []
    for i in range(n):
        p, v = map(int, lines[2 + i].split())
        services.append({'id': i + 1, 'power': p, 'value': v})

    dp = [[State() for _ in range(c + 1)] for _ in range(n + 1)]

    for i in range(1, n + 1):
        service = services[i - 1]
        p, v = service['power'], service['value']
        
        for j in range(c + 1):
            # 不选
            dp[i][j] = dp[i-1][j]
            
            # 选
            if j >= p:
                prev_state = dp[i-1][j-p]
                new_state = State(
                    value=prev_state.value + v,
                    power=prev_state.power + p,
                    count=prev_state.count + 1
                )
                if is_better(new_state, dp[i][j]):
                    dp[i][j] = new_state

    best_state = State()
    final_power = 0
    for j in range(c + 1):
        if is_better(dp[n][j], best_state):
            best_state = dp[n][j]
            final_power = j
            
    if best_state.value == 0:
        print(-1)
        return

    result_ids = []
    current_power = final_power
    for i in range(n, 0, -1):
        if not is_equal(dp[i][current_power], dp[i-1][current_power]):
            service = services[i - 1]
            result_ids.append(service['id'])
            current_power -= service['power']
            
    result_ids.sort()
    print(' '.join(map(str, result_ids)))

solve()