/*
ЗАПУСКАЕМ 
░ГУСЯ░▄▀▀▀▄░РАБОТЯГУ░░
▄███▀░◐░░░▌░░░░░░░
░░░░▌░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▌░░░░░▐▄▄░░░░░
░░░░▌░░░░▄▀▒▒▀▀▀▀▄
░░░▐░░░░▐▒▒▒▒▒▒▒▒▀▀▄
░░░▐░░░░▐▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░▀▄░░░░▀▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░░░▀▄▄▄▄▄█▄▄▄▄▄▄▄▄▄▄▄▀▄
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░▄▄▌▌▄▌▌░░░░░ 
 */
#include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
 
using namespace std;

template<class T1, class T2> inline int chkmin(T1 &x, const T2 &y) {
    if (x > y) {
        x = y;
        return 1;
    }
    else {
        return 0;
    }
}

template<class T1, class T2> inline int chkmax(T1 &x, const T2 &y) {
    if (x < y) {
        x = y;
        return 1;
    }
    else {
        return 0;
    }
}

#define all(c) (c).begin(), (c).end()
#define sz(c) (int)(c).size()
#define mp make_pair
#define pb push_back
#define read(FILENAME) freopen((string(FILENAME) + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((string(FILENAME) + ".out").c_str(), "w", stdout);

template<class iterator> void output(iterator begin, iterator end, ostream &out = cerr) {
    while (begin != end) {
        out << (*begin) << " ";
        begin++;
    }
    out << endl;
}

template<class T> void output(const T &x, ostream &out = cerr) {
    output(x.begin(), x.end(), out);
}

void fast_io() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0); 
}

long long g[3][2];

int main() {
    fast_io();
    //read("input");
    int n;
    cin >> n;
    for (int i = 0; i < 2; i++) {
        cin >> g[0][i] >> g[1][i] >> g[2][i];
    }
    vector<int> st, st1;
    for (int i = 0; i < 3; i++) {
        if (g[i][1] > g[i][0]) {
            st.pb(i);
        } else {
            st1.pb(i);
        }
    }
    if (sz(st) == 3) {
        long long ans = 0;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n - i; j++) {
                int k = n - i - j;
                long long res  = n;
                res += -(i - i % g[0][0]) + (i / g[0][0]) * g[0][1];
                res += -(j - j % g[1][0]) + (j / g[1][0]) * g[1][1];
                res += -(k - k % g[2][0]) + (k / g[2][0]) * g[2][1];
                chkmax(ans, res);
            }
        }
        cout << ans << endl;
        return 0;
    }
    if (sz(st) == 0) {
        long long ans = 0;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n - i; j++) {
                int k = n - i - j;
                long long res  = n;
                res += -(i - i % g[0][1]) + (i / g[0][1]) * g[0][0];
                res += -(j - j % g[1][1]) + (j / g[1][1]) * g[1][0];
                res += -(k - k % g[2][1]) + (k / g[2][1]) * g[2][0];
                chkmax(ans, res);
            }
        }
        cout << ans << endl;
        return 0;
    }
    if (sz(st) == 2) {
        long long ans = 0;
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n - i; j++) {
                long long res  = n;
                res += -(i - i % g[st[0]][0]) + (i / g[st[0]][0]) * g[st[0]][1];
                res += -(j - j % g[st[1]][0]) + (j / g[st[1]][0]) * g[st[1]][1];
                res += -(res - res % g[st1[0]][1]) + (res / g[st1[0]][1]) * g[st1[0]][0];
                chkmax(ans, res);
            }
        }
        cout << ans << endl;
        return 0;
    }
    long long ans = 0;
    long long res  = n;
    res += -(n - n % g[st[0]][0]) + (n / g[st[0]][0]) * g[st[0]][1];
    int rest = res;
    for (int i = 0; i <= rest; i++) {
        res = rest;
        int j = rest - i;
        res += -(i - i % g[st1[0]][1]) + (i / g[st1[0]][1]) * g[st1[0]][0];
        res += -(j - j % g[st1[1]][1]) + (j / g[st1[1]][1]) * g[st1[1]][0];
        chkmax(ans, res);
    }
    cout << ans << endl;
    return 0;
}   


Measured memory_bytes: 256