import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        try (var scanner = new Scanner(new FileInputStream("energii.in"))) {
            var G = Integer.parseInt(scanner.next());
            var W = Integer.parseInt(scanner.next());
            var generatorCosts = new int[G];
            var generatorEnergy = new int[G];
            for (int i = 0; i < G; ++i) {
                generatorEnergy[i] = Integer.parseInt(scanner.next());
                generatorCosts[i] = Integer.parseInt(scanner.next());
            }
            var result = solve(W, generatorCosts, generatorEnergy);
            var path = Path.of("energii.out");
            Files.writeString(path, Integer.toString(result));
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private static int solve(int requiredEnergy, int[] generatorCosts, int[] generatorEnergy) {
        var numberOfGenerators = generatorCosts.length;
        var minCost = new int[numberOfGenerators + 1][requiredEnergy + 1];
        var maxInt = Integer.MAX_VALUE / 2 - 1;
        for (int i = 0; i <= numberOfGenerators; i++) {
            Arrays.fill(minCost[i], maxInt);
        }

        for (int i = 0; i <= requiredEnergy; ++i)
            if (i <= generatorEnergy[0])
                minCost[1][i] = generatorCosts[0];

        for (int i = 2; i <= numberOfGenerators; ++i) {
            var currentCost = generatorCosts[i - 1];
            var currentEnergy = generatorEnergy[i - 1];
            for (int energy = 1; energy <= requiredEnergy; ++energy) {
                if (energy > currentEnergy) {
                    minCost[i][energy] = Math.min(
                            minCost[i - 1][energy],
                            minCost[i - 1][energy - currentEnergy] + currentCost
                    );
                } else {
                    minCost[i][energy] = Math.min(
                            minCost[i - 1][energy],
                            currentCost
                    );
                }
            }
        }
        var result = minCost[numberOfGenerators][requiredEnergy];
        return (result == maxInt) ? -1 : result;
    }

}