#include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
//#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>

//#include <cv.h>
//#include <highgui.h>
#include <stdlib.h>
#include <string>

#include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
//#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>

//#include <cv.h>
//#include <highgui.h>
#include <stdlib.h>
#include <time.h>

#include <string>

const int MAX_N = 100050;
long long N;
long long X[MAX_N];


bool is_possible(const long long num, const std::vector<long long>& vec) {
    for (int i = 0; i < vec.size(); i++) {
        if (vec[i] % num != 0) { return false; }
    }
    return true;
}

const int MAX_D = 20;

int D;
long long p[MAX_D], c[MAX_D];
long long G;

bool can1(long long num, const long long res, const int flag) {
    long long tmp_pt = 0;
    //std::cout << num << " " << res << " " << flag << std::endl;
    for (int i = D; i >= 1; i--) {
        if (((flag >> i) & 1) == 0) {
            long long tmp = std::min(num, p[i]);
            tmp_pt += tmp * 100 * i;
            num -= tmp;
            //std::cout << "check2:" << num << " " << tmp_pt << " " << std::endl;
        }
        if (res <= tmp_pt) {
            //std::cout << "check3:" << num << " " << tmp_pt << " " << std::endl;
            return true;
        }
    }
    return false;
}

bool can2(int num, const long long res) {
    for (int i = 0; i < (1 << D); i++) {
        const int flag = (i << 1);
        long long tmp_pt = 0;
        long long tmp_num = 0;
        for (int i = 1; i <= D; i++) {
            if ((flag >> i) & 1 == 1) {
                tmp_pt += 100 * i * p[i] + c[i];
                tmp_num += p[i];
            }
        }
        if (tmp_num <= num) {
            if (res <= tmp_pt) {
                return true;
            }
            //std::cout << "check1:" << tmp_num << " " << tmp_pt << " " << flag << std::endl;
            if (can1(num - tmp_num, res - tmp_pt, flag)) {
                //std::cout << "check4:" << tmp_num << " " << tmp_pt << " " << flag << std::endl;
                return true;
            }
        }
    }
    return false;
}

int main(int argc, char **argv) {
    std::cin >> D >> G;

    for (int i = 1; i <= D; i++) {
        std::cin >> p[i] >> c[i];
    }

    //std::cout << (can2(7, G) ? 1 : 0) << std::endl;

    long long total = 0;
    for (int i = 1; i <= D; i++) {
        total += p[i];
    }

    long long lb = 0;
    long long ub = total;

    while (true) {
        if (lb + 1 == ub) { break; }
        long long mid = (lb + ub)/2;
        if (can2(mid, G)) {
            ub = mid;
        } else {
            lb = mid;
        }
    }

    std::cout << ub << std::endl;
    
    return 0;

}

Measured memory_bytes: 256