#include <iostream>
#include <vector>
#include <array>
#include <climits>
#include <fstream>

using namespace std;

int minimum_cost(int number_of_generators, int necessary_power, const vector<int> &generator_power,
                 const vector<int> &generator_cost) {

    const auto inf = INT_MAX / 2 - 1;

    vector<vector<int> > dp(number_of_generators + 1, vector<int>(necessary_power + 1, inf));

    for (int i = 0; i <= necessary_power; i++) {
        if (generator_power[0] >= i) {
            dp[1][i] = generator_cost[0];
        }
    }
    for (int i = 2; i <= number_of_generators; i++) {
        for (int j = 1; j <= necessary_power; j++) {

            if (generator_power[i - 1] >= j) {
                dp[i][j] = min(
                        generator_cost[i - 1],
                        dp[i - 1][j]
                );
            } else {
                dp[i][j] = min(
                        dp[i - 1][j],
                        dp[i - 1][j - generator_power[i - 1]] + generator_cost[i - 1]
                );
            }
        }
    }
    return dp[number_of_generators][necessary_power] == inf ? -1 : dp[number_of_generators][necessary_power];
}

int main() {
    ifstream fin("energii.in");
    ofstream fout("energii.out");

    int number_of_generators{};
    int necessary_power{};

    fin >> number_of_generators >> necessary_power;
    vector<int> generator_power(number_of_generators);
    vector<int> generator_cost(number_of_generators);
    for (int i = 0; i < number_of_generators; i++) {
        fin >> generator_power[i];
        fin >> generator_cost[i];
    }
    fout << minimum_cost(number_of_generators, necessary_power, generator_power, generator_cost);
    return 0;
}