Problem:
Score : 300 points

Problem Statement

A programming competition site AtCode provides algorithmic problems.
Each problem is allocated a score based on its difficulty.
Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points.
These p_1 + … + p_D problems are all of the problems available on AtCode.

A user of AtCode has a value called total score.
The total score of a user is the sum of the following two elements:

Base score: the sum of the scores of all problems solved by the user.

Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 ≤ i ≤ D).

Takahashi, who is the new user of AtCode, has not solved any problem.
His objective is to have a total score of G or more points.
At least how many problems does he need to solve for this objective?

Constraints

1 ≤ D ≤ 10

1 ≤ p_i ≤ 100

100 ≤ c_i ≤ 10^6

100 ≤ G

All values in input are integers.

c_i and G are all multiples of 100.

It is possible to have a total score of G or more points.

Input

Input is given from Standard Input in the following format:

D G
p_1 c_1
:
p_D c_D

Output

Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).

Sample Input 1

2 700
3 500
5 800

Sample Output 1

3

In this case, there are three problems each with 100 points and five problems each with 200 points. The perfect bonus for solving all the 100-point problems is 500 points, and the perfect bonus for solving all the 200-point problems is 800 points. Takahashi's objective is to have a total score of 700 points or more.

One way to achieve this objective is to solve four 200-point problems and earn a base score of 800 points. However, if we solve three 100-point problems, we can earn the perfect bonus of 500 points in addition to the base score of 300 points, for a total score of 800 points, and we can achieve the objective with fewer problems.

Sample Input 2

2 2000
3 500
5 800

Sample Output 2

7

This case is similar to Sample Input 1, but the Takahashi's objective this time is 2000 points or more. In this case, we inevitably need to solve all five 200-point problems, and by solving two 100-point problems additionally we have the total score of 2000 points.

Sample Input 3

2 400
3 500
5 800

Sample Output 3

2

This case is again similar to Sample Input 1, but the Takahashi's objective this time is 400 points or more. In this case, we only need to solve two 200-point problems to achieve the objective.

Sample Input 4

5 25000
20 1000
40 1000
50 1000
30 1000
1 1000

Sample Output 4

66

There is only one 500-point problem, but the perfect bonus can be earned even in such a case.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
using namespace std;
void rd(int &x){
  int k, m=0;
  x=0;
  for(;;){
    k = getchar_unlocked();
    if(k=='-'){
      m=1;
      break;
    }
    if('0'<=k&&k<='9'){
      x=k-'0';
      break;
    }
  }
  for(;;){
    k = getchar_unlocked();
    if(k<'0'||k>'9'){
      break;
    }
    x=x*10+k-'0';
  }
  if(m){
    x=-x;
  }
}
void wt_L(int x){
  char f[10];
  int m=0, s=0;
  if(x<0){
    m=1;
    x=-x;
  }
  while(x){
    f[s++]=x%10;
    x/=10;
  }
  if(!s){
    f[s++]=0;
  }
  if(m){
    putchar_unlocked('-');
  }
  while(s--){
    putchar_unlocked(f[s]+'0');
  }
}
template<class S, class T> inline S divup_L(S a, T b){
  return (a+b-1)/b;
}
template<class S, class T> inline S chmin(S &a, T b){
  if(a>b){
    a=b;
  }
  return a;
}
int C[10], D, G, P[10];
int main(){
  int i, j, k, res=1073709056, x, y;
  rd(D);
  rd(G);
  {
    int Lj4PdHRW;
    for(Lj4PdHRW=0;Lj4PdHRW<D;Lj4PdHRW++){
      rd(P[Lj4PdHRW]);
      rd(C[Lj4PdHRW]);
    }
  }
  G /= 100;
  {
    int KL2GvlyY;
    for(KL2GvlyY=0;KL2GvlyY<(D-1) + 1;KL2GvlyY++){
      C[KL2GvlyY] /= 100;
    }
  }
  for(k=0;k<1<<D;k++){
    x = y = 0;
    j = -1;
    for(i=0;i<D;i++){
      if(k&1<<i){
        x += P[i];
        y += (i+1) * P[i] + C[i];
      }
      else{
        j = i;
      }
    }
    if(y >= G){
      chmin(res, x);
      continue;
    }
    if(j == -1){
      continue;
    }
    if(y + (j+1) * P[j] < G){
      continue;
    }
    chmin(res, x +divup_L((G-y),(j+1)));
  }
  wt_L(res);
  putchar_unlocked('\n');
  return 0;
}
// cLay varsion 20180730-1

// --- original code ---
// int D, G, P[10], C[10];
// {
//   int i, j, k;
//   int x, y, res = int_inf;
// 
//   rd(D,G,(P,C)(D));
//   G /= 100;
//   C[0..D-1] /= 100;
// 
//   rep(k,1<<D){
//     x = y = 0;
//     j = -1;
//     rep(i,D){
//       if(k&1<<i) x += P[i], y += (i+1) * P[i] + C[i];
//       else       j = i;
//     }
//     if(y >= G){ res <?= x; continue; }
//     if(j == -1) continue;
//     if(y + (j+1) * P[j] < G) continue;
//     res <?= x + (G-y) /+ (j+1);
//   }
// 
//   wt(res);
// }