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)

if D < 10:
    for i in range(D):
        tar = i

        ind_list = list(range(D))
        ind_list.remove(tar)
        ind_list = np.array(ind_list)

        P_part = np.hstack((P[:tar], P[tar+1:]))
        C_part = np.hstack((C[:tar], C[tar+1:]))

        cnt_part = np.zeros(D-1,dtype=int)#[0 for _ in range(D-1)]
        point_part = np.zeros(D-1,dtype=int)#[0 for _ in range(D-1)]

        bit_list = np.ones(D-1,dtype=int)
        point_part_max = np.sum(((ind_list+1) * 100 * P_part + C_part)*bit_list)

        cnt_tar_min = max(0,(G - point_part_max)//((tar+1)*100))

        if cnt_tar_min > P[tar]:
            continue
        for cnt_tar in range(cnt_tar_min,P[tar]+1):
            point_base = cnt_tar*(tar+1)*100

            num_base   = cnt_tar + C[tar]*max(0,cnt_tar-P[tar] + 1)

            if point_base >= G or num_base >= ans:
                num = num_base
                ans = min(ans,num)
                break
            elif point_base + point_part_max >= G:

                for bit_seed in range(2**(D-1)):

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

                    cnt_part = P_part*bit_list
                    num = num_base + np.sum(cnt_part)
                    if num > ans:
                        continue

                    point_part = cnt_part * (ind_list+1) * 100 + C_part*bit_list
                    point = point_base + np.sum(point_part)

                    if point >= G:
                        ans = min(ans,num)

    print(ans)
    exit()

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

            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)


### 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)