#include <bits/stdc++.h>
#define rep(i, m, n) for(int i = m; i < (n); i++)
#define print(x) cout << (x) << endl;
#define printv(x) for(int i = 0; i < x.size(); i++){ cout << (x[i]) << " "; } cout << endl; 
#define printa(x,n) for(int i = 0; i < n; i++){ cout << (x[i]) << " ";} cout << endl;
#define printaa(x) for(int i = 0; i < (sizeof(x)/sizeof(x[0])); i++){ for(int j = 0; j < (sizeof(x[0])/sizeof(x[0][0])); j++){ cout << x[i][j] << " ";} cout << endl;}
#define INF (1e9)
typedef long long ll;
typedef struct{
    int x;
    int y;
} P;

using namespace std;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    char num[5] = {'a', 'b', 'c', 'd', 'e'};
    int D,G;
    ll p[20];
    ll c[20];
    cin >> D >> G;
    rep(i,0,D){
        cin >> p[i] >> c[i];
    }
    int ans = 1e5;

    rep(i,0,(1<<D)){
        int sum = 0;
        int max_pos = -1;
        int count = 0;
        rep(j,0,D){
            if((i >> j) & 1){
                sum += c[j] + (j+1) * 100 * p[j];
                count += p[j];
            }else{
                max_pos = max(max_pos, j);
            }
        }
        if(sum >= G){
            ans = min(ans, count);
        }else if(max_pos != -1){
            int g = G - sum;
            int t = 0;
            while(g > 0 && t <= p[max_pos] - 1 ){
                g -= (max_pos + 1) * 100;
                count++;
                t++;
            }
            if(g <= 0){
                ans = min(ans, count);
            }
        }



    }
    print(ans);

    // rep(i,0,2048){
    //     int N = i;
    //     while(1){
    //         if(N == 0) break;
            
    //     }        
    // }
    // ll dd[20] = {};
    // double dd_2[20] = {};
    // rep(i,0,D){
    //     dd[i] = c[i] + p[i] * 100 * (i+1);
    //     dd_2[i] = double(dd[i]);
    //     dd_2[i] /= p[i];
    // }
    // int g = G;
    // ll ans = 0;
    // int is_use[20] = {};
    // while(1){
    //     print(g);
    //     int max_val = 0;
    //     int max_pos = -1;
    //     rep(i,0,D){
    //         if(is_use[i] == 0 && max_val < dd_2[i]){
    //             max_val = dd_2[i];
    //             max_pos = i;
    //         }
    //     }
    //     is_use[max_pos] = 1;
    //     print(dd[max_pos]);
    //     if(g > dd[max_pos]){
    //         g -= dd[max_pos];
    //         ans += p[max_pos];
    //     }else{
    //         int count_tmp = p[max_pos];
    //         int mp = -1;
    //         rep(i,0,D){
    //             if(is_use[i] == 0){
    //                 mp = i;
    //             }
    //         }
    //         if(mp != -1){
    //             count_tmp = min(count_tmp, (g/(100*(mp+1))) + 1);
    //         }
    //         ans += count_tmp;
    //         break;
    //     }
    // }
    // print(ans);
    // int min_pos = 1000;
    // int is_use[20] = {};
    // while(1){
    //     rep(i,0,D){
    //         if(is_use[i] == 0 && dd[i] >= G){
    //             if(p[i] < min_pos){
    //                 min_pos = p[i];

    //             }
    //         }
    //     }
    //     if(is_use[i] == 0 && )
    // }

    // ll dd[20][110] = {};
    // rep(i,0,D){
    //     int num_p = p[i];
    //     rep(j,0,num_p - 1){
    //         dd[i][j] = (i+1) * 100;
    //     }
    //     dd[i][num_p-1] = (i+1) * 100 + c[i];
    // }
    // int count[20] = {};
    // ll ans = 0;
    // ll sum = 0;
    // while(1){
    //     ll max_val = 0;
    //     ll max_pos = -1;
    //     rep(i,0,D){
    //         if(dd[i][count[i]] > max_val && count[i] != -1){
    //             max_pos = i;
    //             max_val = dd[i][count[i]];
    //         }
    //     }
    //     count[max_pos]++;
    //     if(count[max_pos] == p[max_pos]){
    //         count[max_pos] = -1;
    //     }
    //     ans++;
    //     print(max_val);
    //     sum += max_val;
    //     if(sum >= G) break;
    // }
    // print(ans);


}


Measured memory_bytes: 256