

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



#prob_num = [3,5]

#comp = [500,800]



prob_num = []

comp = []



for i in range(D):

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

    prob_num.append(p)

    comp.append(c)



comp_point = []

for i in range(D):

    comp_point.append((100*(i+1)*prob_num[i]+comp[i]))







ans = 1000000

for b in range(1<<D):

    hasComp = []

    for j in range(D):

        if b & (1<<j):

            hasComp.append(True)

        else:

            hasComp.append(False)

        

    # compしてるものを決め打ち

    point = 0

    prb = 0

    for i in range(D):

        if hasComp[i]:

            point += comp_point[i]

            prb += prob_num[i]

    

    res = G-point

    

    while res>0:

        flag = 0

        for i in range(D-1,-1,-1):

            if not hasComp[i]:

                if res <= (100*(i+1)*(prob_num[i]-1)):

                    req_prob = (res//(100*(i+1))) + bool(res%(100*(i+1)))

                    prb += req_prob

                    res = 0

                    break

                

                else:

                    prb += (prob_num[i]-1)

                    res -= (100*(i+1))*(prob_num[i]-1)

        

            if i==0:

                flag = 1

                break

        

        if flag:

            break

    if res<=0:

        ans = min(ans,prb)

    

print(ans)

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

prob_num = []

bonus = []

comp_pt = []

for i in range(D):

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

    prob_num.append(p)

    bonus.append(b)

    comp_pt.append(100*(i+1)*p+b)



def dfs(hascomp:str, target:int, prob:int, depth:int) -> int:

    if target <= 0:

        #print(hascomp, depth, prob)

        return prob

    

    elif depth == D:

        for i in range(D-1,-1,-1):

            if hascomp[i] == "n":

                if target <= 100*(i+1)*(prob_num[i]-1):

                    prob += (target//(100*(i+1)))+bool(target%(100*(i+1)))

                    #print(hascomp, depth, prob)

                    return prob

                

                else:

                    prob += (prob_num[i]-1)

                    target -= 100*(i+1)*(prob_num[i]-1)

                    

        if target > 0:

            #print(hascomp, depth, prob)

            return 10**5

        

    else:

        new_tar = target-comp_pt[depth]

        new_prob = prob + prob_num[depth]

        return min(dfs(hascomp+"y",new_tar, new_prob, depth+1),

                   dfs(hascomp+"n",target, prob, depth+1))

        



ans = dfs("",G,0,0)

print(ans)
D, G = list(map(int, input().split()))
# prob_num = [3,5]
# comp = [500,800]
prob_num = []
comp = []
for i in range(D):
    p, c = list(map(int, input().split()))
    prob_num.append(p)
    comp.append(c)
comp_point = []
for i in range(D):
    comp_point.append((100 * (i + 1) * prob_num[i] + comp[i]))
ans = 1000000
for b in range(1 << D):
    hasComp = []
    for j in range(D):
        if b & (1 << j):
            hasComp.append(True)
        else:
            hasComp.append(False)
    # compしてるものを決め打ち
    point = 0
    prb = 0
    for i in range(D):
        if hasComp[i]:
            point += comp_point[i]
            prb += prob_num[i]
    res = G - point
    while res > 0:
        flag = 0
        for i in range(D - 1, -1, -1):
            if not hasComp[i]:
                if res <= (100 * (i + 1) * (prob_num[i] - 1)):
                    req_prob = (res // (100 * (i + 1))) + bool(res % (100 * (i + 1)))
                    prb += req_prob
                    res = 0
                    break
                else:
                    prb += prob_num[i] - 1
                    res -= (100 * (i + 1)) * (prob_num[i] - 1)
            if i == 0:
                flag = 1
                break
        if flag:
            break
    if res <= 0:
        ans = min(ans, prb)
print(ans)

D, G = list(map(int, input().split()))
prob_num = []
bonus = []
comp_pt = []
for i in range(D):
    p, b = list(map(int, input().split()))
    prob_num.append(p)
    bonus.append(b)
    comp_pt.append(100 * (i + 1) * p + b)


def dfs(hascomp: str, target: int, prob: int, depth: int) -> int:
    if target <= 0:
        # print(hascomp, depth, prob)
        return prob
    elif depth == D:
        for i in range(D - 1, -1, -1):
            if hascomp[i] == "n":
                if target <= 100 * (i + 1) * (prob_num[i] - 1):
                    prob += (target // (100 * (i + 1))) + bool(target % (100 * (i + 1)))
                    # print(hascomp, depth, prob)
                    return prob
                else:
                    prob += prob_num[i] - 1
                    target -= 100 * (i + 1) * (prob_num[i] - 1)
        if target > 0:
            # print(hascomp, depth, prob)
            return 10**5
    else:
        new_tar = target - comp_pt[depth]
        new_prob = prob + prob_num[depth]
        return min(
            dfs(hascomp + "y", new_tar, new_prob, depth + 1),
            dfs(hascomp + "n", target, prob, depth + 1),
        )


ans = dfs("", G, 0, 0)
print(ans)

-# prob_num = [3,5] -# comp = [500,800] -comp = [] +bonus = [] +comp_pt = [] -    p, c = list(map(int, input().split())) +    p, b = list(map(int, input().split())) -    comp.append(c) -comp_point = [] -for i in range(D): -    comp_point.append((100 * (i + 1) * prob_num[i] + comp[i])) -ans = 1000000 -for b in range(1 << D): -    hasComp = [] -    for j in range(D): -        if b & (1 << j): -            hasComp.append(True) -        else: -            hasComp.append(False) -    # compしてるものを決め打ち -    point = 0 -    prb = 0 -    for i in range(D): -        if hasComp[i]: -            point += comp_point[i] -            prb += prob_num[i] -    res = G - point -    while res > 0: -        flag = 0 +    bonus.append(b) +    comp_pt.append(100 * (i + 1) * p + b) + + +def dfs(hascomp: str, target: int, prob: int, depth: int) -> int: +    if target <= 0: +        # print(hascomp, depth, prob) +        return prob +    elif depth == D: -            if not hasComp[i]: -                if res <= (100 * (i + 1) * (prob_num[i] - 1)): -                    req_prob = (res // (100 * (i + 1))) + bool(res % (100 * (i + 1))) -                    prb += req_prob -                    res = 0 -                    break +            if hascomp[i] == "n": +                if target <= 100 * (i + 1) * (prob_num[i] - 1): +                    prob += (target // (100 * (i + 1))) + bool(target % (100 * (i + 1))) +                    # print(hascomp, depth, prob) +                    return prob -                    prb += prob_num[i] - 1 -                    res -= (100 * (i + 1)) * (prob_num[i] - 1) -            if i == 0: -                flag = 1 -                break -        if flag: -            break -    if res <= 0: -        ans = min(ans, prb) +                    prob += prob_num[i] - 1 +                    target -= 100 * (i + 1) * (prob_num[i] - 1) +        if target > 0: +            # print(hascomp, depth, prob) +            return 10**5 +    else: +        new_tar = target - comp_pt[depth] +        new_prob = prob + prob_num[depth] +        return min( +            dfs(hascomp + "y", new_tar, new_prob, depth + 1), +            dfs(hascomp + "n", target, prob, depth + 1), +        ) + + +ans = dfs("", G, 0, 0)