// O(A^3)解法 (TLE想定)
// mod2048でDP配列を循環させてMLEを回避する手法
fn solve(n: u64, ab: [(u64, u64); 3]) -> u64 {
    let (a_min, a_max, b_min, b_max) = ab.iter().fold((!0u64, 0u64, !0u64, 0u64), |(a_min, a_max, b_min, b_max), &(a, b)| (a.min(a_min), a.max(a_max), b.min(b_min), b.max(b_max)));
    assert!(n > 0 && a_min > 0 && a_max < 2048 && b_min > 0);
    assert!((n / a_min).saturating_mul(b_max) < (1u64 << 61));
    let a_lcm = ab
        .iter()
        .map(|e| e.0)
        .reduce(|a, b| a / gcd(a, b) * b)
        .unwrap();
    let mut dp = [i64::MIN; 2048];
    dp[0] = 0;
    let mut v = 0;
    if n <= a_lcm {
        for i in 1..=n {
            for &(a, b) in ab.iter() {
                v.chmax(dp[(i.wrapping_sub(a) & 2047) as usize] + (b as i64));
            }
            dp[(i & 2047) as usize] = v;
        }
    } else {
        for i in 1..=a_lcm {
            for &(a, b) in ab.iter() {
                v.chmax(dp[(i.wrapping_sub(a) & 2047) as usize] + (b as i64));
            }
            dp[(i & 2047) as usize] = v;
        }
        let v_lcm = v;
        for i in a_lcm..=((n % a_lcm) + a_lcm) {
            for &(a, b) in ab.iter() {
                v.chmax(dp[(i.wrapping_sub(a) & 2047) as usize] + (b as i64));
            }
            dp[(i & 2047) as usize] = v;
        }
        v += v_lcm * ((n / a_lcm - 1) as i64);
    }
    v as u64
}

fn main() {
	let mut stdinlock = std::io::stdin().lock();
	let mut lines = std::io::BufRead::lines(&mut stdinlock);
	let n = lines.next().unwrap().unwrap().parse::<u64>().unwrap();
	let ab = (0..3).map(|_| {
		let s = lines.next().unwrap().unwrap();
		let mut t = s.split_whitespace();
		(
            t.next().unwrap().parse::<u64>().unwrap(),
            t.next().unwrap().parse::<u64>().unwrap(),
		)
	}).collect::<Vec<_>>();
    println!("{}", solve(n, [ab[0], ab[1], ab[2]]));
}

fn gcd(mut a: u64, mut b: u64) -> u64 {
    if a == 0 || b == 0 {
        return a | b;
    }
    let (tza, tzb) = (a.trailing_zeros(), b.trailing_zeros());
    a >>= tza;
    b >>= tzb;
    let tzt = tza.min(tzb);
    while a != b {
        if a > b {
            a -= b;
            a >>= a.trailing_zeros();
        } else {
            b -= a;
            b >>= b.trailing_zeros();
        }
    }
    a << tzt
}

trait Change {
    fn chmax(&mut self, x: Self);
    fn chmin(&mut self, x: Self);
}
impl<T: PartialOrd> Change for T {
    fn chmax(&mut self, x: T) {
        if *self < x {
            *self = x;
        }
    }
    fn chmin(&mut self, x: T) {
        if *self > x {
            *self = x;
        }
    }
}