#![allow(unused_imports, dead_code, unused_macros, unused_variables, non_snake_case, unused_parens)]
use proconio::{input,marker::{Bytes, Chars, Usize1,Isize1}};
use std::{ops::*, vec};
use std::cmp::*;
use std::mem::swap;
use std::collections::*;

const MOD:u64 = 1_000_000_007;
const INF:i64 = 0x3fff_ffff_ffff_ffff;
const YES:&str="Yes";const NO:&str="No";macro_rules!yesno{($var:expr) => {if $var{println!("{}",YES);}else{println!("{}",NO);}}}

macro_rules! min {($a:expr $(,)*) => {{$a}};($a:expr, $b:expr $(,)*) => {{std::cmp::min($a, $b)}};($a:expr, $($rest:expr),+ $(,)*) => {{std::cmp::min($a, min!($($rest),+))}};}
macro_rules! max {($a:expr $(,)*) => {{$a}};($a:expr, $b:expr $(,)*) => {{std::cmp::max($a, $b)}};($a:expr, $($rest:expr),+ $(,)*) => {{std::cmp::max($a, max!($($rest),+))}};}
macro_rules! chmin {($base:expr, $($cmps:expr),+ $(,)*) => {{let cmp_min = min!($($cmps),+);if $base > cmp_min {$base = cmp_min;true} else {false}}};}
macro_rules! chmax {($base:expr, $($cmps:expr),+ $(,)*) => {{let cmp_max = max!($($cmps),+);if $base < cmp_max {$base = cmp_max;true} else {false}}};}
macro_rules! mulvec {($x:expr; $s:expr) => {vec![$x; $s]};($x:expr; $s0:expr; $( $s:expr );+) => {mulvec![vec![$x; $s0]; $( $s );+ ]};}
macro_rules! outputln {($var:expr)=>{println!("{}",$var)};($var:expr,$($vars:expr),+)=>{print!("{} ",$var);outputln!($($vars),+);};}
macro_rules! debug {($($a:expr),* $(,)*) => {eprintln!(concat!($("| ",stringify!($a), "={:?} "),*, "|"),$(&$a),*);};}


fn solve() {
    input! {
        mut R: i64,
        mut P: i64,
        mut Q: i64,
        mut A: i64,
        mut B: i64,
        mut C: i64,
        mut D: i64,
    }
	let mut ans = 0;
	let mut ABC = vec![A,B,C];
	ABC.sort();
	A = ABC[0];
	B = ABC[1];
	C = ABC[2];
	// まずルーマニア人を最大限作る
	let d = min!(A,B,C, R/P);
	ans += d;
	A -= d;
	B -= d;
	C -= d;
	R -= d*P;
	// A,B,Cのうち2番目の人数を一番少ない人数に合わせる。
	let d = min!(B - A, D, R / (P+Q));
	ans += d;
	B -= d;
	C -= d;
	D -= d;
	R -= d*(P+Q);
	// DをA,Bに分配
	let d = min!(C - B, D/2, R / (P+Q+Q));
	ans += d;
	C -= d;
	D -= d*2;
	R -= d*(P+Q+Q);
	// Dを均等に配分
	let d = min!(D / 3, R / (P + Q*3));
	ans += d;
	D -= d*3;
	R -= d*(P+Q*3);
	// CをAに配分
	let d = min!(B-A, C-B, R / (P+Q));
	ans += d;
	C -= d*2;
	B -= d;
	R -= d * (P+Q);
	// CをA,Bに配分
	let d = min!((C-A)/2, R / (P+Q*2));
	ans += d;
	C -= d*3;
	R -= d * (P+Q*2);

	debug!((A,B,C,D), R);

	outputln!(ans);

}

fn main() {
    std::thread::Builder::new()
        .stack_size(128 * 1024 * 1024)
        .spawn(|| solve()).unwrap()
        .join().unwrap();
}