#include <iostream>
#include <vector>
#include <cstdio>
#include <queue>
#include <algorithm>
#include <functional>
#include <string>
#include <queue>
#include <cmath>
#include <iomanip>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <random>
#include <unordered_map>
#include <unordered_set>
#define ll long long
#define fr(i,k,N) for(ll i=k; i<N;i++)
#define rep(i,N) for(ll i=0; i<N;i++)
#define ALL(v) v.begin(),v.end()
#define mp make_pair
using namespace std;
template <class X> void pr(X test){cout<<test<<endl;}
template <class X> void prr(X test){for(auto it:test){cout<<it<<endl;}}
template <class X> void prrr(X test){int f=0;for(auto it:test){cout<<(f++!=0?" ":"")<<it;}cout<<endl;}
template<typename X>
istream&operator>>(istream&i,vector<X>&v){for(X&x:v)i>>x;return i;}

class UF { // union find from https://github.com/kartikkukreja/blog-codes (MIT)
    // [usage]
    // auto uf = new UF(n);
    // uf->merge(l, r); // 0 <= l, r <= n-1
    // ...
public:
    int *id; // inner id
    int cnt; // number of all vartices
    int *sz; // sz[i] means size of i's set
    UF(int N)   {
        cnt = N;
        id = new int[N];
        sz = new int[N];
        for(int i=0; i<N; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }
    ~UF() {
        delete [] id;
        delete [] sz;
    }
    int find(int p) {
        int root = p;
        while (root != id[root]) root = id[root];
        while (p != root) {
            int newp = id[p];
            id[p] = root;
            p = newp;
        }
        return root;
    }
    void merge(int x, int y) {
        int i = find(x);
        int j = find(y);
        if (i == j) return;
        
        if (sz[i] < sz[j]) {
            id[i] = j;
            sz[j] += sz[i];
        } else {
            id[j] = i;
            sz[i] += sz[j];
        }
        cnt--;
    }
    bool connected(int x, int y) {
        return find(x) == find(y);
    }
    int count() {
        return cnt;
    }
};

// return sorted 約数list 1 <= x <= n
vector<ll> divv(ll n) {
  vector<ll> v;
  for(ll i = 1; i*i <= n; i++) {
    if(n%i == 0) {
      v.push_back(i);
      if(i*i != n) v.push_back(n/i);
    }
  }
  sort(ALL(v));
  return v;
}

int main() {
    ll n;
    cin>>n;
    ll g1,g2,s1,s2,b1,b2;
    cin>>g1>>s1>>b1;
    cin>>g2>>s2>>b2;
    // if(g1>g2) swap(g1,g2);
    // if(s1>s2) swap(s1,s2);
    // if(b1>b2) swap(b1,b2);
{
    pair<ll, ll> dp[5001];
    rep(i, 5001) dp[i] = mp(0,0);
    fr(i,1, n+1) {

        vector<pair<ll,ll>> pp;
        ll g = 0;
        ll gs = 0;

        if(g2>g1 && i - g1 >= 0) {
            g = dp[i - g1].first + g2;
            gs = dp[i - g1].second + g1;
        }
        pp.push_back(mp(-g,gs));
        ll s = 0;
        ll ss = 0;
        if(s2>s1 && i - s1 >= 0) {
            s = dp[i - s1].first + s2;
            ss= dp[i - s1].second + s1;
        }
        pp.push_back(mp(-s,ss));
        ll b = 0;
        ll bs=0;
        if(b2>b1 && i - b1 >= 0) {
            b = dp[i - b1].first + b2;
            bs =dp[i - b1].second + b1;
        }
        pp.push_back(mp(-b,bs));
        sort(ALL(pp));
        dp[i].first = -pp[0].first;
        dp[i].second = pp[0].second;

        // pr(dp[i].first + i - dp[i].second);
    }
    // pr(dp[n].first + n - dp[n].second);

    n = dp[n].first + n - dp[n].second;
}

    swap(g1,g2);
    swap(s1,s2);
    swap(b1,b2);
{
    vector<pair<ll, ll>> dp(n+1);
    rep(i, n+1) dp[i] = mp(0,0);
    // pr("n is ...");pr(n);
        vector<pair<ll,ll>> pp(3);
    fr(i,1, n+1) {
        // pr(i);

        ll g = 0;
        ll gs = 0;

        if(g2>g1 && i - g1 >= 0) {
            g = dp[i - g1].first + g2;
            gs = dp[i - g1].second + g1;
        }
        pp[0]=(mp(-g,gs));
        ll s = 0;
        ll ss = 0;
        if(s2>s1 && i - s1 >= 0) {
            s = dp[i - s1].first + s2;
            ss= dp[i - s1].second + s1;
        }
        pp[1]=(mp(-s,ss));
        ll b = 0;
        ll bs=0;
        if(b2>b1 && i - b1 >= 0) {
            b = dp[i - b1].first + b2;
            bs =dp[i - b1].second + b1;
        }
        pp[2]=(mp(-b,bs));
        sort(ALL(pp));
        dp[i].first = -pp[0].first;
        dp[i].second = pp[0].second;

        // pr(dp[i].first + i - dp[i].second);
    }
    pr(dp[n].first + n - dp[n].second);
}
return 0;
}


Measured memory_bytes: 390912