import math

d, g = list(map(int, input().split()))



ps = []

cs = []

for i in range(d):

  p, c = list(map(int, input().split()))

  ps.append(p)

  cs.append(c)

  

ans = []  

def solve(s):

  global ans

  if len(s) == d:

    total = 0

    cnt = 0

    for i in range(len(s)):

      total += int(s[i]) * (ps[i]*(i+1)*100 + cs[i]) #全部解いたときの点

      cnt += int(s[i]) * ps[i]

    if total >= g:

      #return cnt

      ans.append(cnt)

      return

    else:

      #解いていない中で得点が最大の問題を探す

      s = s[::-1]

      idx = s.find("0")

      if s == -1:

        return

      #溶けるだけ解いてgを超えるならおk

      if math.ceil((g-total) /  ((d-idx)*100)) < ps[d-1-idx]:

        cnt += math.ceil((g-total) /  ((d-idx)*100))

        #return cnt

        ans.append(cnt)

        return

      else:

        #return 0

        return

      return

  solve(s+"0")

  solve(s+"1")



  

solve("")

print((min(ans)))
# ビット演算を使おう



D, G = list(map(int, input().split()))

pc = [tuple(map(int,input().split())) for i in range(D)]

import math

ans = 10**5

for i in range(2**D):

    # 使い切る部分が１、選ばない部分が０

    b = str(bin(i))[2:].zfill(D)

    



    cnt = 0

    point = 0

    first_zero_idx = 0

    flag = False

    #print(b)

    for j in range(len(b)):

        # 解ききる問題の点とボーナスの和

        if b[j] == "1":

            point += (D-j)*100*pc[D-1-j][0] + pc[D-1-j][1]

            cnt += pc[D-1-j][0]

        else:

            if not flag:

                first_zero_idx = j

                flag = True

    if flag:

        # 残りのうち最も得点の高い問題を解いたときにボーダーを超えるかどうか

        if point < G and G - point <= (pc[D-1-first_zero_idx][0]-1)*100*(D-first_zero_idx):

            #print(b, point, cnt)

            tmp = math.ceil((G - point) / (100*(D-first_zero_idx)))

            cnt += tmp

            point += tmp*100*(D-first_zero_idx)

    if point >= G:

        ans = min(ans, cnt)

        #print("---",b, point, cnt, tmp, first_zero_idx)

        

print(ans)

import math

d, g = list(map(int, input().split()))
ps = []
cs = []
for i in range(d):
    p, c = list(map(int, input().split()))
    ps.append(p)
    cs.append(c)
ans = []


def solve(s):
    global ans
    if len(s) == d:
        total = 0
        cnt = 0
        for i in range(len(s)):
            total += int(s[i]) * (ps[i] * (i + 1) * 100 + cs[i])  # 全部解いたときの点
            cnt += int(s[i]) * ps[i]
        if total >= g:
            # return cnt
            ans.append(cnt)
            return
        else:
            # 解いていない中で得点が最大の問題を探す
            s = s[::-1]
            idx = s.find("0")
            if s == -1:
                return
            # 溶けるだけ解いてgを超えるならおk
            if math.ceil((g - total) / ((d - idx) * 100)) < ps[d - 1 - idx]:
                cnt += math.ceil((g - total) / ((d - idx) * 100))
                # return cnt
                ans.append(cnt)
                return
            else:
                # return 0
                return
            return
    solve(s + "0")
    solve(s + "1")


solve("")
print((min(ans)))

# ビット演算を使おう
D, G = list(map(int, input().split()))
pc = [tuple(map(int, input().split())) for i in range(D)]
import math

ans = 10**5
for i in range(2**D):
    # 使い切る部分が１、選ばない部分が０
    b = str(bin(i))[2:].zfill(D)
    cnt = 0
    point = 0
    first_zero_idx = 0
    flag = False
    # print(b)
    for j in range(len(b)):
        # 解ききる問題の点とボーナスの和
        if b[j] == "1":
            point += (D - j) * 100 * pc[D - 1 - j][0] + pc[D - 1 - j][1]
            cnt += pc[D - 1 - j][0]
        else:
            if not flag:
                first_zero_idx = j
                flag = True
    if flag:
        # 残りのうち最も得点の高い問題を解いたときにボーダーを超えるかどうか
        if point < G and G - point <= (pc[D - 1 - first_zero_idx][0] - 1) * 100 * (
            D - first_zero_idx
        ):
            # print(b, point, cnt)
            tmp = math.ceil((G - point) / (100 * (D - first_zero_idx)))
            cnt += tmp
            point += tmp * 100 * (D - first_zero_idx)
    if point >= G:
        ans = min(ans, cnt)
        # print("---",b, point, cnt, tmp, first_zero_idx)
print(ans)

+# ビット演算を使おう +D, G = list(map(int, input().split())) +pc = [tuple(map(int, input().split())) for i in range(D)] -d, g = list(map(int, input().split())) -ps = [] -cs = [] -for i in range(d): -    p, c = list(map(int, input().split())) -    ps.append(p) -    cs.append(c) -ans = [] - - -def solve(s): -    global ans -    if len(s) == d: -        total = 0 -        cnt = 0 -        for i in range(len(s)): -            total += int(s[i]) * (ps[i] * (i + 1) * 100 + cs[i])  # 全部解いたときの点 -            cnt += int(s[i]) * ps[i] -        if total >= g: -            # return cnt -            ans.append(cnt) -            return +ans = 10**5 +for i in range(2**D): +    # 使い切る部分が１、選ばない部分が０ +    b = str(bin(i))[2:].zfill(D) +    cnt = 0 +    point = 0 +    first_zero_idx = 0 +    flag = False +    # print(b) +    for j in range(len(b)): +        # 解ききる問題の点とボーナスの和 +        if b[j] == "1": +            point += (D - j) * 100 * pc[D - 1 - j][0] + pc[D - 1 - j][1] +            cnt += pc[D - 1 - j][0] -            # 解いていない中で得点が最大の問題を探す -            s = s[::-1] -            idx = s.find("0") -            if s == -1: -                return -            # 溶けるだけ解いてgを超えるならおk -            if math.ceil((g - total) / ((d - idx) * 100)) < ps[d - 1 - idx]: -                cnt += math.ceil((g - total) / ((d - idx) * 100)) -                # return cnt -                ans.append(cnt) -                return -            else: -                # return 0 -                return -            return -    solve(s + "0") -    solve(s + "1") - - -solve("") -print((min(ans))) +            if not flag: +                first_zero_idx = j +                flag = True +    if flag: +        # 残りのうち最も得点の高い問題を解いたときにボーダーを超えるかどうか +        if point < G and G - point <= (pc[D - 1 - first_zero_idx][0] - 1) * 100 * ( +            D - first_zero_idx +        ): +            # print(b, point, cnt) +            tmp = math.ceil((G - point) / (100 * (D - first_zero_idx))) +            cnt += tmp +            point += tmp * 100 * (D - first_zero_idx) +    if point >= G: +        ans = min(ans, cnt) +print(ans)