// The very basic /////////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
#define ALL_H 1

// Print elements of containers using << operator /////////////////////////////
// pair
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {
  return s << "(" << p.first << ", " << p.second << ")";}
// vector
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
  for (auto &elem : v) {
    s << elem;
    if (&elem != &v.back()) s << " ";
  }
  return s;
}
// 2 dimentional vector
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
  for (auto &elem : vv) {
    s << elem;
    if (&elem != &vv.back()) s << endl;
  }
  return s;
}
// map
template<typename T1, typename T2> ostream& operator<<(ostream& s, const map<T1, T2>& m) {
  s << "{" << endl;
  for (auto &elem: m) {
    s << " " << elem.first << " : " << elem.second << endl;
  }
  s << "}";
  return s;
}
//set
template<typename T> ostream& operator<<(ostream& s, const set<T>& m) {
  s << "{ ";
  for (auto &elem: m) {
    s << elem << " ";
  }
  s << "}";
  return s;
}

// Convenient macros //////////////////////////////////////////////////////////

// types
#define ll long long
#define ld long double
#define int ll
#define Pi pair<int, int>
#define Graph vector<vector<int>>
#define WeightGraph vector<vector<Pi>>

// other
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
#define allr(x) (x).rbegin(),(x).rend()
#define perm(c) sort(all(c));for(bool c##p=1;c##p;c##p=next_permutation(all(c)))

#define MOD 1000000007
#define INF LLONG_MAX/100

// update max or min //////////////////////////////////////////////////////////

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

// gcd
int gcd(int a,int b){return b?gcd(b,a%b):a;}

// direction
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};


// division
// roundup
#define divu(x,y) ((x) + (y) - 1) / (y)
// r
#define divr(x,y) ((x) + (y/2)) / (y)

// Debug it by D(x) ///////////////////////////////////////////////////////////
#define DEBUG 0
#if DEBUG
#define D(x) x
#else
#define D(x)
#endif

///////////////////////////////////////////////////////////////////////////////
//                             Start Coding Here                             //
///////////////////////////////////////////////////////////////////////////////

signed main() {
  int N, G;
  cin >> N >> G;
  vector<Pi> items(N);
  map<int, int> bonus;
  rep(i, N) {
    int a, b; cin >> a >> b;
    items[i] = make_pair((i+1)*100, a);
    bonus[(i+1)*100] = b;
  }

  int P = 1 << N;
  int ans = INF;
  rep(i, P) {
    int nitem = 0;
    int gain = 0;
    int maxj = -1;
    int cm = -1;
    rep(j, N) {
      int mask = 1 << j;   // if get bonus
      if (i & mask) {
        nitem += items[j].second;
        gain += items[j].first * items[j].second;
        gain += bonus[items[j].first];
      } else {
        if (chmax(cm, items[j].first)) maxj = j;
      }
    }

    D(cout << bitset<8>(i) << endl);
    D(cout << cm << " " << maxj << endl);
    // gain check
    if (gain >= G) {
      D(cout << "here1" << endl);
      chmin(ans, nitem);
    } else {
      // make up with other
      int rem = G - gain;
      int need = divu(rem, items[maxj].first);
      if (need <= items[maxj].second) {
        D(cout << "here2" << endl);
        nitem += need;
        chmin(ans, nitem);
      }
    }
    D(cout << ans << endl);
  }
  cout << ans << endl;
}


Measured memory_bytes: 256