using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
//using System.Text;
//using System.Text.RegularExpressions;
//using System.Globalization;
//using System.Diagnostics;
using static System.Console;
//using System.Numerics;
//using static System.Math;
//using pair = Pair<int, int>;

class Program
{
    static void Main()
    {
        //SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
        new Program().solve();
        Out.Flush();
    }
    Scanner cin = new Scanner();
    readonly int[] dd = { 0, 1, 0, -1, 0 }; //→↓←↑
    readonly int mod = 1000000007;
    void chmax<T>(ref T a, T b) where T : IComparable<T> { a = a.CompareTo(b) < 0 ? b : a; }
    void chmin<T>(ref T a, T b) where T : IComparable<T> { a = a.CompareTo(b) < 0 ? a : b; }

    void solve()
    {
        int D = cin.nextint;
        int G = cin.nextint / 100;
        var A = Enumerable.Range(0, D).ToArray();
        var P = new int[D];
        var C = new int[D];
        for (int i = 0; i < D; i++)
        {
            P[i] = cin.nextint;
            C[i] = cin.nextint / 100;
        }
        int ans = int.MaxValue;
        do
        {
            int HP = G;
            int sum = 0;
            foreach (var v in A)
            {
                int num = (HP + v) / (v + 1);
                if (num < P[v])
                {
                    chmin(ref ans, sum + num);
                    break;
                }
                HP -= (v + 1) * P[v] + C[v];
                sum += P[v];
                if (HP <= 0)
                {
                    chmin(ref ans, sum);
                    break;
                }
            }
        } while (next_permutation(A));

        WriteLine(ans);
    }

    bool next_permutation<T>(T[] array) where T : IComparable<T>
    {
        return next_permutation(array, 0, array.Length);
    }
    bool next_permutation<T>(T[] array, int start, int length) where T : IComparable<T>
    {
        int end = start + length - 1;
        if (end <= start) return false;
        int last = end;
        while (true)
        {
            int pos = last--;
            if (array[last].CompareTo(array[pos]) < 0)
            {
                int i;
                for (i = end + 1; array[last].CompareTo(array[--i]) >= 0;) { }
                T tmp = array[last]; array[last] = array[i]; array[i] = tmp;
                Array.Reverse(array, pos, end - pos + 1);
                return true;
            }
            if (last == start)
            {
                //Array.Reverse(array, start, end - start + 1);
                return false;
            }
        }
    }
}

class Scanner
{
    string[] s; int i;
    char[] cs = new char[] { ' ' };
    public Scanner() { s = new string[0]; i = 0; }
    public string[] scan { get { return ReadLine().Split(); } }
    public int[] scanint { get { return Array.ConvertAll(scan, int.Parse); } }
    public long[] scanlong { get { return Array.ConvertAll(scan, long.Parse); } }
    public double[] scandouble { get { return Array.ConvertAll(scan, double.Parse); } }
    public string next
    {
        get
        {
            if (i < s.Length) return s[i++];
            string st = ReadLine();
            while (st == "") st = ReadLine();
            s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
            i = 0;
            return next;
        }
    }
    public int nextint { get { return int.Parse(next); } }
    public long nextlong { get { return long.Parse(next); } }
    public double nextdouble { get { return double.Parse(next); } }
}

Measured memory_bytes: 13268