#include <bits/stdc++.h>
using namespace std;

#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x, y) CPP_CAT_I(x, y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x, y) x##y

#define ASSERT(expr...) assert((expr))

using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;

using f32 = float;
using f64 = double;
// }}}

constexpr i64 INF = 1'010'000'000'000'000'017LL;

constexpr i64 MOD = 998244353LL;

constexpr f64 EPS = 1e-12;

constexpr f64 PI = 3.14159265358979323846;

#define M5 100007
#define M9 1000000000

#define F first
#define S second

// util {{{
#define FOR(i, start, end) for (i64 i = (start), CPP_CAT(i, xxxx_end) = (end); i < CPP_CAT(i, xxxx_end); ++i)
#define REP(i, n) FOR(i, 0, n)

#define all(x) (x).begin(), (x).end()
#define ll long long int
#define VI vector<ll>
#define VVI vector<VI>

#define ISD true
#define debug(x) \
    if (ISD)     \
    cout << #x << ": " << x << endl

template <typename T, typename U, typename Comp = less<>>
bool chmax(T &xmax, const U &x, Comp comp = {})
{
    if (comp(xmax, x))
    {
        xmax = x;
        return true;
    }
    return false;
}

template <typename T, typename U, typename Comp = less<>>
bool chmin(T &xmin, const U &x, Comp comp = {})
{
    if (comp(x, xmin))
    {
        xmin = x;
        return true;
    }
    return false;
}

using P = pair<ll, ll>;

ll mod(ll x, ll y)
{ // x%yをxが負の場合でも使えるように拡張
    if (x < 0)
        x += (abs(x) / y) * y + y;
    return x % y;
}

vector<ll> crt1(ll x, ll y)
{
    // x>=yで入れる！！(x<yでも使えるかもしれないがそこのエラーチェックをしていないので)
    //  x*s-y*t=gcd(x,y)となるs,t,gcdを返す
    if (x % y == 0)
        return {1, x / y - 1, y};

    // xs-yt=v[2](gcd)を満たす
    // →x=(x/y)*y+(x%y)なので、
    // (x%y)=x-(x/y)*y・・・(1)
    // y*v[0]-(x%y)*v[1]=v[2]に(1)を代入して、
    // y*v[0]-(x-(x/y)*y)*v[1]=v[2]となる。これを整理して、
    // -v[1]*x+(v[0]+(x/y)*v[1])*y=v[2]
    // となるので、s=-v[1]のときにs,tの整数解が存在することがわかる。
    auto v = crt1(y, x % y);
    ll s = mod(-v[1], y / v[2]);
    ll t = (x * s - v[2]) / y;
    return {s, t, v[2]};
}

P crt2(ll a, ll b, ll c, ll d)
{
    // a mod bかつ、c mod dとなるval mod(lcm(b,d))

    // c-aがgcd(b,d)で割り切れない場合は、条件を満たすものは存在しない
    if (abs(c - a) % __gcd(b, d) != 0)
        return {INF, -1};

    // b>dの形に統一しておく
    if (b < d)
    {
        swap(b, d);
        swap(a, c);
    }

    // まず、crt1をもちいてbx-dy=gcd(b,d)となるものを求め、
    auto v = crt1(b, d);

    // それを((c-a)/gcd(b,d))倍することで、bx-dy=c-aを満たすxが求まる
    // (ここでmod dすることでこれを満たす最小のxになる)
    ll val = mod(v[0] * ((c - a) / v[2]), d);

    // 今、xを求めたので、この値からxb+aをもとめる。
    val = val * b + a;
    ll lcm = b * d / v[2];

    // 多分必要ないが、一応modをとっている(いらなさそうだが、これを消してテストしていないので)
    val = mod(val, lcm);

    return {val, lcm};
}

P crt(vector<ll> rem, vector<ll> div)
{
    // CRT(crt2のn個拡張版) remに余り、divに法をindexが一致するように入れる
    ll x = 0;
    ll y = 1;
    P v;
    // x,yにたいしてrem, divにあるものを使って、crt2で行った操作を加えていく
    REP(i, rem.size())
    {
        if (y < div[i])
        {
            swap(x, rem[i]);
            swap(y, div[i]);
        }
        v = crt2(x, y, rem[i], div[i]);
        if (v.second == -1)
            return {-1, -1};
        x = v.first;
        y = v.second;
    }
    return v;
}

int main()
{
    ll N;
    cin >> N;
    vector<ll> PQR(3);
    REP(i, 3)
    cin >> PQR[i];
    vector<ll> ABC(3);
    REP(i, 3)
    cin >> ABC[i];

    auto p = crt(ABC, PQR);
    ll ans = N / p.S;
    if (N % p.S >= p.F)
        ans++;
    cout << ans << endl;
}