#include <iostream>

using namespace std;

int main() {
    int D,G;
    cin >> D >>G ;
    int p[12]={0};
    int c[12]={0};
    int judge[12]={0};
    int nmin=0;
    
    for (int i=0; i<D; i++) {
        cin >> p[i+1] >> c[i+1];
        judge[i+1] =1;
        nmin +=  p[i+1];
    }
    
    int n[12];
    
    for (n[1]=0; n[1] < judge[1]+1; n[1]++) {
        
        for (n[2]=0; n[2] < judge[2]+1; n[2]++) {
            
            for (n[3]=0; n[3] < judge[3]+1; n[3]++) {
                
                for (n[4]=0; n[4] < judge[4]+1; n[4]++) {
                    
                    for (n[5]=0; n[5] < judge[5]+1; n[5]++) {
                        
                        for (n[6]=0; n[6] < judge[6]+1; n[6]++) {
                            
                            for (n[7]=0; n[7] < judge[7]+1; n[7]++) {
                                
                                for (n[8]=0; n[8] < judge[8]+1; n[8]++) {
                                    
                                    for (n[9]=0; n[9] < judge[9]+1; n[9]++) {
                                        
                                        for (n[10]=0; n[10] < judge[10]+1; n[10]++) {
                                            
                                            int all=0;
                                            int nall=0;
                                            
                                            
                                            for (int i=1; i<(D+1); i++) {
                                                all  += (100 * i * p[i] + c[i])* n[i] ;
                                                nall += p[i] * n[i];
                                            }
                                            
                                            int half=0;
                                            for (int i=0; i<D; i++) {
                                                if(n[D-i] == 0){
                                                    half =D-i;
                                                    break;
                                                }
                                            }
                                            
                                            
                                            for (int i=0; i<p[half]; i++) {
                                                if(nall > nmin) break;
                                                
                                                if (all>(G-1) && nall<nmin){
                                                    nmin = nall;
                                                    break;
                                                }
                                                
                                                all  +=100*half;
                                                nall +=1;
                                            }
                                            
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    cout << nmin <<endl;
    
    return 0;
}

Measured memory_bytes: 256