#![allow(unused_mut, unused_macros, unused_variables, unused_assignments, non_snake_case, unused_imports, dead_code, non_camel_case_types)]

use std::collections::{HashMap, BinaryHeap, BTreeMap};

// [Rustで競技プログラミングの入力をスッキリ記述するマクロ - Qiita]
// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 から拝借
macro_rules! input {
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};
    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };
    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };
    // ABC128-C-Switches用に拡張
    ($next:expr, [ $t:tt ]) => {{
        let len = read_value!($next, $t);
        (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    }};
    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };
    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };
    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

// 可愛い可愛い、お手製のライブラリ達
// 出力
macro_rules! p {
    ($t:expr) => {
        println!("{}", $t);
    };
}
macro_rules! debug {
    ($t:expr) => {
        println!("{:?}", $t);
    };
}
// 最大公約数 / 最小公倍数
fn gcd(a:usize, b:usize) -> usize {
    if b == 0 {return a};
    gcd(b, a % b)
}
fn lcm(a:usize, b:usize) -> usize {
    a / gcd(a, b) * b
}
// Union-Find木
struct uft {
    g: Vec<isize>,
}
impl uft {
    fn new(n:usize) -> uft {
        uft {g:vec![-1; n]}
    }
    fn root(&mut self, a:usize) -> usize {
        let va = self.g[a];
        if va.is_negative() {a}
        else {
            let na = self.root(va as usize);
            self.g[a] = na as isize;
            na
        }
    }
    fn merge(&mut self, a:usize, b:usize) -> bool {
        let (na, nb) = (self.root(a), self.root(b));
        if na == nb {return false;}
        self.g[na] += self.g[nb];
        self.g[nb] = na as isize;
        true
    }
    fn size(&mut self, a:usize) -> usize {
        let na = self.root(a);
        (self.g[na] * -1) as usize
    }
}
// グラフ(DFS/BFS)

use std::cmp::{max, min};

fn solve(bars:&Vec<usize>, a:usize, b:usize, c:usize, cost:usize, A:usize, B:usize, C:usize) -> usize {
    if bars.is_empty() {
        if a == 0 || b == 0 || c == 0 {return std::usize::MAX;}
        let mut temp = cost;
        temp += max(a, A) - min(a, A);
        temp += max(b, B) - min(b, B);
        temp += max(c, C) - min(c, C);
        return temp - 30;
    }
    let bar = bars[0];
    let nbars = {
        let mut nbars = Vec::new();
        for bar in bars.into_iter().skip(1) {nbars.push(*bar);}
        nbars
    };
    let mut ret = vec![0, 0, 0, 0];
    ret[0] = solve(&nbars, a, b, c, cost, A, B, C);
    ret[1] = solve(&nbars, a + bar, b, c, cost + 10, A, B, C);
    ret[2] = solve(&nbars, a, b + bar, c, cost + 10, A, B, C);
    ret[3] = solve(&nbars, a, b, c + bar, cost + 10, A, B, C);

    *ret.iter().min().unwrap()
}

// エントリーポイント
fn main() {
    input! {
        N : usize,
        A : usize,
        B : usize,
        C : usize,
        L : [usize; N]
    }
    p!(solve(&L, 0, 0, 0, 0, A, B, C));
}


Measured memory_bytes: 4352