### BUGGY CODE ###

def kuriage(cnt,P,ind,tar,C,G):

    if cnt[ind] == 0:
        cnt[ind:ind+1] = P[ind:ind+1]
    elif cnt[ind] == P[ind]:
        if 0 in cnt[:tar] and 0 in cnt[tar+1:]:
            if ind+1 == tar:
                kuriage(cnt,P,ind+2, tar, C, G)
            else:
                kuriage(cnt,P,ind+1, tar, C, G)
        else:
            if C[tar] != P[tar]:
                C[tar] = C[tar] + 1
            else:
                C[tar] = -1
    return cnt
def point_over(cnt,P,C,G):
    point = 0
    for i in range(len(P)):
        point += cnt[i]*100*(i+1)
        if cnt[i] == P[i]:
            point += C[i]

        if point >= G:
            return True

    if point < G:
        return False

def point(cnt,P,C):
    point = 0

    for i,cnt_s in enumerate(cnt):
        print(cnt_s,'ok')
        if cnt_s == 0:
            point += 0
        else:
            point += cnt[i]*100*(i+1) + C[i]
    return point

D,G = map(int, input().split())
P = []
C = []

for i in range(D):
    p,c = map(int,input().split())
    P.append(p)
    C.append(c)

cnt = [0 for _ in range(D)]

ans = sum(P)
cnt_tar = 0

for i in range(D):
    tar = i

    P_part = P[:tar] + P[tar+1:]
    C_part = C[:tar] + C[tar+1:]

    cnt_part = [0 for _ in range(D-1)]
    point_part = [0 for _ in range(D-1)]

    for cnt_tar in range(P[tar]+1):
        point_base = cnt_tar*(tar+1)*100

        num_base   = cnt_tar
        if cnt_tar == P[tar]:
            point_base += C[tar]

        if True:
#            print('point_base = ',point_base,)
            for bit_seed in range(2**(D-1)):

                s_bit = (format(bit_seed, '#011b'))[::-1]

                for j in range(D-1):
                    bit = int(s_bit[j:j+1])
                    cnt_part[j]   = (P_part[j])*bit
                    point_part[j] = (P_part[j]*(P.index(P_part[j])+1)*100 + C_part[j])*bit

                num = num_base + sum(cnt_part)
                point = point_base + sum(point_part)
#                print(cnt_tar,cnt_part,point)
                if point >= G:
                    # print('point = ',point,'/',G)
                    # print(num)
                    ans = min(ans,num)

print(ans)
#     while cnt_part != P_part:
#     ind = 0

#     cnt = kuriage(cnt,P,ind,tar,C,G)
#     print(cnt)
#     if cnt[tar] == -1:
#         cnt = [0 for _ in range(D)]
#         tar += 1

#     if point_over(cnt,P,C,G) and ans > sum(cnt):
#         ans = min(ans, sum(cnt))
# #            print(ans)

# print(ans)


### FIXED CODE ###

import numpy as np

D,G = map(int, input().split())
P = []
C = []

for i in range(D):
    p,c = map(int,input().split())
    P.append(p)
    C.append(c)

cnt = np.zeros(D,dtype=int)
P = np.array(P)
C = np.array(C)

ans = sum(P)
cnt_tar = 0

ind_list = np.arange(D)

for bit_seed in range(2**D):

    s_bit = (format(bit_seed, '#016b'))[::-1]
    bit_list = np.array(list(s_bit[:D]),dtype=int)

    cnt = P*bit_list
    num_base = np.sum(cnt)

    point_base_array = (P * (ind_list+1) * 100 + C) * bit_list
    point_base = np.sum(point_base_array)
#    print(point_base_array)

    if point_base >= G:
        num = num_base
        ans = min(ans,num)
    elif num_base > ans:
        continue
    else:
        for i,bit in enumerate(bit_list):
            if bit == 0:
                tar = i

        point_max = point_base + P[tar]*(tar+1)*100 + C[tar]
        if point_max >= G:

            tar_min = (G-point_base) // ((tar+1)*100)
            point = point_base + P[tar]*(tar+1)*100*tar_min

            if point < G:
                tar_min += 1

            if tar_min < P[tar]:
                num = num_base + tar_min
            else:
                num = num_base + P[tar]
            ans = min(ans,num)

print(ans)