import kotlin.math.min

fun main() {
    val (d, g) = nextIntList()
    val countList = mutableListOf<Int>()
    val estList = mutableListOf<List<Int>>()
    repeat(d) {
        val v = it.plus(1).times(100)
        val (p, c) = nextIntList()
        countList.add(p)
        val list = mutableListOf<Int>()
        (0 until p).forEach {
            list.add(v * it)
        }
        list.add(v * p + c)
        estList.add(list)
    }
//    println(countList)
//    println(estList)

    fun dfs(_d: Int, n: Int): Int {
        if (_d < d) {
            return min(
                dfs(_d + 1, (n shl 1)),
                dfs(_d + 1, (n shl 1) or 1)
            )
        }
        val list = mutableListOf<Int>()
        var m = n
        var s = 0
        var c = 0
        repeat(d) {
            val b = m and 1
            m = m shr 1
//            print("$b ")

            if (b == 1) {
                s += estList[it].last()
                c += countList[it]
            } else {
                list.add(it)
            }
        }
//        println(n)
//        println("s: $s, c: $c")
//        println(list)
        if (s >= g) return c
        return list.map { i ->
            val index = estList[i].indexOfFirst {
                s + it >= g
            }
            if (index >= 0) {
                c + index
            } else {
                Int.MAX_VALUE
            }
        }.min() ?: Int.MAX_VALUE
    }

    println(dfs(0, 0))
}


// # Utils
// ## Input
fun next() = readLine()!!
fun nextInt() = next().toInt()
fun nextLong() = next().toLong()
fun nextDouble() = next().toDouble()
fun nextList() = next().split(" ")
fun nextIntList() = next().split(" ").map(String::toInt)
fun nextLongList() = next().split(" ").map(String::toLong)
fun nextDoubleList() = next().split(" ").map(String::toDouble)

// ## Array
inline fun <reified T> sizedArray(size: Int, default: T) = Array(size) { default }
inline fun <reified T> sized2DArray(row: Int, column: Int, default: T) = Array(row) { Array(column) { default } }

// ## mod^-1
//    [NOTE] CANNOT use this for 0, mod, 2mod, 3mod ...(return wrong value)
fun modinv(num: Long, mod: Long): Long {
    var a = num
    var b = mod
    var u = 1L
    var v = 0L
    while (b > 0) {
        val t = a.div(b)
        a -= t * b
        a = b.also { b = a } // swap a and b
        u -= t * v
        u = v.also { v = u } // swap u and v
    }
    u %= mod
    if (u < 0) u += mod
    return u
}

fun gcd(x: Int, y: Int): Int {
    fun innerGcd(x: Int, y: Int): Int {
        return if (x % y == 0) y else innerGcd(y, x % y)
    }
    return if (x >= y) innerGcd(x, y) else innerGcd(y, x)
}

fun gcd(x: Long, y: Long): Long {
    fun innerGcd(x: Long, y: Long): Long {
        return if (x % y == 0L) y else innerGcd(y, x % y)
    }
    return if (x >= y) innerGcd(x, y) else innerGcd(y, x)
}

// classes
class UnionFindTree(val size: Int) {
    private val r = sizedArray(size, -1)
    fun root(x: Int): Int {
        if (r[x] < 0) return x
        return root(r[x])
    }

    fun unite(x: Int, y: Int) {
        var rx = root(x)
        var ry = root(y)
        if (rx == ry) return
        if (r[rx] > r[ry]) {
            rx = ry.also { ry = rx }
        }
        r[rx] += r[ry]
        r[ry] = rx
    }

    fun size(x: Int) = -r[root(x)]

    override fun toString(): String {
        return r.joinToString(separator = ", ")
    }
}

Measured memory_bytes: 39512