# ABC119C - Synthetic Kadomatsu

N, A, B, C = list(map(int, input().split()))

L = [int(eval(input())) for i in range(N)]



INF = float('inf')



def dfs(cursor=0, a=0, b=0, c=0):  # cursor:カーソル a,b,c:現在の竹の長さ

    if cursor == N:  # cursorが最後まで行ったら終了する。

        return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF

    # abs(a - A) + abs(b - B) + abs(c - C) - 30でなぜ 30を減じているのかというと、

    # dfs(0,0,0,0)で始まる以上、最初に選ばれるa,b,cを決定する際にもコストが 10増加してしまうからである。

    # また、全探索を行う中で、a,b,cの初期値が 0,0,0である以上、a,b,cのどれかが 0のまま終了する場合が存在する。

    # この場合はa,b,cに竹が対応してないと言えるため、解にはならない。

    # そこで三項演算子を利用して、その場合についてコストをINFとしている



    # 以下は4^Nで展開される再起処理となる。

    # カーソルの当たっている竹に対して、(A or B or Cに合成する) or (合成しない)の場合に分ける

    no_compound_pattern = dfs(cursor + 1, a, b, c)

    compound_a_pattern = dfs(cursor + 1, a + L[cursor], b, c) + 10

    compound_b_pattern = dfs(cursor + 1, a, b + L[cursor], c) + 10

    compound_c_pattern = dfs(cursor + 1, a, b, c + L[cursor]) + 10



    # 結果的に以下の値が返るのはそれぞれのパターンのコストが決定されてからなので

    # 以下のコードは最終的なコストの最小値

    return min(

        no_compound_pattern, compound_a_pattern, compound_b_pattern, compound_c_pattern

    )





print((dfs()))
n, *goals = list(map(int, input().split()))

bamboos = list(map(int, [input().rstrip() for _ in range(n)]))





def get_best(li, goal):

    bam_mp_lis = {0: (-10, tuple())}

    li.sort()

    for i, v in enumerate(li):

        tmp = bam_mp_lis.copy()

        for bam, (mp, lis) in list(tmp.items()):

            b0 = bam + v

            m0 = mp + 10

            l0 = lis + (i,)

            if b0 not in bam_mp_lis or m0 < bam_mp_lis[b0][0]:

                bam_mp_lis[b0] = (m0, l0)

    del bam_mp_lis[0]

    best = 10 ** 9

    for bam, (mp, lis) in list(bam_mp_lis.items()):

        cost = mp + abs(goal - bam)

        if cost < best:

            best = cost

            beslis = lis

    return best, beslis





ans = 10 ** 9

from itertools import permutations



for junjo in permutations(goals):

    tmp = 0

    bambooo = bamboos.copy()

    for ju in junjo:

        if len(bambooo) == 0:

            tmp = 10 ** 9

            break

        be, beli = get_best(bambooo, ju)

        beli = sorted(beli, reverse=True)

        for beli0 in beli:

            del bambooo[beli0]

        tmp += be

    if tmp < ans:

        ans = tmp



print(ans)
# ABC119C - Synthetic Kadomatsu
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for i in range(N)]
INF = float("inf")


def dfs(cursor=0, a=0, b=0, c=0):  # cursor:カーソル a,b,c:現在の竹の長さ
    if cursor == N:  # cursorが最後まで行ったら終了する。
        return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
    # abs(a - A) + abs(b - B) + abs(c - C) - 30でなぜ 30を減じているのかというと、
    # dfs(0,0,0,0)で始まる以上、最初に選ばれるa,b,cを決定する際にもコストが 10増加してしまうからである。
    # また、全探索を行う中で、a,b,cの初期値が 0,0,0である以上、a,b,cのどれかが 0のまま終了する場合が存在する。
    # この場合はa,b,cに竹が対応してないと言えるため、解にはならない。
    # そこで三項演算子を利用して、その場合についてコストをINFとしている
    # 以下は4^Nで展開される再起処理となる。
    # カーソルの当たっている竹に対して、(A or B or Cに合成する) or (合成しない)の場合に分ける
    no_compound_pattern = dfs(cursor + 1, a, b, c)
    compound_a_pattern = dfs(cursor + 1, a + L[cursor], b, c) + 10
    compound_b_pattern = dfs(cursor + 1, a, b + L[cursor], c) + 10
    compound_c_pattern = dfs(cursor + 1, a, b, c + L[cursor]) + 10
    # 結果的に以下の値が返るのはそれぞれのパターンのコストが決定されてからなので
    # 以下のコードは最終的なコストの最小値
    return min(
        no_compound_pattern, compound_a_pattern, compound_b_pattern, compound_c_pattern
    )


print((dfs()))

n, *goals = list(map(int, input().split()))
bamboos = list(map(int, [input().rstrip() for _ in range(n)]))


def get_best(li, goal):
    bam_mp_lis = {0: (-10, tuple())}
    li.sort()
    for i, v in enumerate(li):
        tmp = bam_mp_lis.copy()
        for bam, (mp, lis) in list(tmp.items()):
            b0 = bam + v
            m0 = mp + 10
            l0 = lis + (i,)
            if b0 not in bam_mp_lis or m0 < bam_mp_lis[b0][0]:
                bam_mp_lis[b0] = (m0, l0)
    del bam_mp_lis[0]
    best = 10**9
    for bam, (mp, lis) in list(bam_mp_lis.items()):
        cost = mp + abs(goal - bam)
        if cost < best:
            best = cost
            beslis = lis
    return best, beslis


ans = 10**9
from itertools import permutations

for junjo in permutations(goals):
    tmp = 0
    bambooo = bamboos.copy()
    for ju in junjo:
        if len(bambooo) == 0:
            tmp = 10**9
            break
        be, beli = get_best(bambooo, ju)
        beli = sorted(beli, reverse=True)
        for beli0 in beli:
            del bambooo[beli0]
        tmp += be
    if tmp < ans:
        ans = tmp
print(ans)

-# ABC119C - Synthetic Kadomatsu -N, A, B, C = list(map(int, input().split())) -L = [int(eval(input())) for i in range(N)] -INF = float("inf") +n, *goals = list(map(int, input().split())) +bamboos = list(map(int, [input().rstrip() for _ in range(n)])) -def dfs(cursor=0, a=0, b=0, c=0):  # cursor:カーソル a,b,c:現在の竹の長さ -    if cursor == N:  # cursorが最後まで行ったら終了する。 -        return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF -    # abs(a - A) + abs(b - B) + abs(c - C) - 30でなぜ 30を減じているのかというと、 -    # dfs(0,0,0,0)で始まる以上、最初に選ばれるa,b,cを決定する際にもコストが 10増加してしまうからである。 -    # また、全探索を行う中で、a,b,cの初期値が 0,0,0である以上、a,b,cのどれかが 0のまま終了する場合が存在する。 -    # この場合はa,b,cに竹が対応してないと言えるため、解にはならない。 -    # そこで三項演算子を利用して、その場合についてコストをINFとしている -    # 以下は4^Nで展開される再起処理となる。 -    # カーソルの当たっている竹に対して、(A or B or Cに合成する) or (合成しない)の場合に分ける -    no_compound_pattern = dfs(cursor + 1, a, b, c) -    compound_a_pattern = dfs(cursor + 1, a + L[cursor], b, c) + 10 -    compound_b_pattern = dfs(cursor + 1, a, b + L[cursor], c) + 10 -    compound_c_pattern = dfs(cursor + 1, a, b, c + L[cursor]) + 10 -    # 結果的に以下の値が返るのはそれぞれのパターンのコストが決定されてからなので -    # 以下のコードは最終的なコストの最小値 -    return min( -        no_compound_pattern, compound_a_pattern, compound_b_pattern, compound_c_pattern -    ) +def get_best(li, goal): +    bam_mp_lis = {0: (-10, tuple())} +    li.sort() +    for i, v in enumerate(li): +        tmp = bam_mp_lis.copy() +        for bam, (mp, lis) in list(tmp.items()): +            b0 = bam + v +            m0 = mp + 10 +            l0 = lis + (i,) +            if b0 not in bam_mp_lis or m0 < bam_mp_lis[b0][0]: +                bam_mp_lis[b0] = (m0, l0) +    del bam_mp_lis[0] +    best = 10**9 +    for bam, (mp, lis) in list(bam_mp_lis.items()): +        cost = mp + abs(goal - bam) +        if cost < best: +            best = cost +            beslis = lis +    return best, beslis -print((dfs())) +ans = 10**9 +from itertools import permutations + +for junjo in permutations(goals): +    tmp = 0 +    bambooo = bamboos.copy() +    for ju in junjo: +        if len(bambooo) == 0: +            tmp = 10**9 +            break +        be, beli = get_best(bambooo, ju) +        beli = sorted(beli, reverse=True) +        for beli0 in beli: +            del bambooo[beli0] +        tmp += be +    if tmp < ans: +        ans = tmp +print(ans)