//
// Created by 35395 on 2024/10/9.
//
#include<bits/stdc++.h>
using namespace std;
using ll = long long;

const int N = 410;

int n;
ll b[N], c[N];
int sum[N];
pair<ll, int> a[N];
using std::array, std::bitset, std::deque, std::function, std::greater, std::less, std::map, std::multiset, std::pair, std::priority_queue, std::queue, std::set, std::stack, std::string, std::vector;using NAME = void;using ch = char;using ll = long long;using ull = unsigned long long;using ld = long double;using i128 = __int128_t;using u128 = __uint128_t;using f128 = __float128;template <typename T, ull n>using A = array<T, n>;template <typename T, typename TT>using P = pair<T, TT>;template <typename T>using ve = vector<T>;template <typename T>using pq = priority_queue<T>;template <typename T>using rpq = priority_queue<T, std::vector<T>, std::greater<T>>;template <typename T, auto cmp>using sec = set<T, decltype(cmp)>;template <typename T, auto cmp>using msec = multiset<T, decltype(cmp)>;template <typename T, auto cmp>using pqc = priority_queue<T, std::vector<T>, decltype(cmp)>;
#define meion       auto
#define iroha       return
namespace MeIoN_Pre_Things {
    namespace MEION = std::ranges;
    std::mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
    std::uniform_int_distribution<ll> rd(1e8,1e9);
    std::default_random_engine e;
    constexpr ll mod99 = 998244353, mod17 = 1000000007, mod = mod99;
    constexpr ld pi = 3.1415926535897932384626433832795L;
    int T = 1;
    ll INT = std::numeric_limits<ll>::max();
    constexpr ld eps = 1E-8L;
    inline ll inv(ll x) { iroha x == 1 ? 1 : (ll)(mod - mod / x) * inv(mod % x) % mod; }
    inline ll ksm(ll a, ll b){ll res = 1; while(b){ if(b & 1) { res = (res * a) % mod; } a = a * a % mod; b >>= 1; } iroha res % mod; }
    template <typename T> inline int MeIoN_count(T n) { iroha std::__popcount(n); }
    template <typename T> inline int MeIoN_clz(T n)   { iroha std::__countl_zero(n); }
    template <typename T> inline T lowbit(T x) { iroha x & -x; }
    template <typename T> inline void MAX(T& a, T b) { a = std::max(a, b); }
    template <typename T> inline void MIN(T& a, T b) { a = std::min(a, b); }
    template <typename T> inline void unique (vector<T> &v) { MEION::sort(v); v.erase(std::unique(v.begin(), v.end()), v.end()); v.shrink_to_fit(); }
} using namespace MeIoN_Pre_Things;
namespace MeIoN_IO {
    std::istream &operator>>(std::istream &is, i128 &n) { string s; is >> s; n = 0; for (const char c : s) n = n * 10 + c - '0'; iroha is; }
    std::ostream &operator<<(std::ostream &os, i128 n) { string s; while (n) s += '0' + n % 10, n /= 10; if (s.empty()) s += '0'; MEION::reverse(s); iroha os << s; }
    std::istream &operator>>(std::istream &is, f128 &n) { string s; is >> s; n = std::stold(s); iroha is; }
    std::ostream &operator<<(std::ostream &os, f128 n)  { iroha os << ld(n); }
    template <typename T, typename S> std::istream &operator>>(std::istream &is, std::pair<T, S> &any) { is >> any.first >> any.second; iroha is; }
    template <typename T, typename S> std::ostream &operator<<(std::ostream &os, std::pair<T, S> &any) { os << any.first << ' ' << any.second; iroha os; }
    template <typename T, const size_t n> std::istream &operator>>(std::istream &is, std::array<T, n> &v) { for (size_t i = 0; i < n; ++i) is >> v[i]; iroha is; }
    template <typename T, const size_t n> std::ostream &operator<<(std::ostream &os, std::array<T, n> &v) { for (size_t i = 0; i < n; ++i) { os << v[i]; if (i + 1 != n) os << ' ';} iroha os; }
    template <typename T> std::istream &operator>>(std::istream &is, std::vector<T> &v) { for (meion &i : v) is >> i; iroha is; }
    template <typename T> std::ostream &operator<<(std::ostream &os, std::vector<T> &v) { for (size_t i = 0, ed = v.size(); i < ed; ++i) { os << v[i]; if (i + 1 != ed) std::cout << ' '; } iroha os; }
    template <typename T> std::ostream &operator<<(std::ostream &os, std::vector<std::vector<T>> &v) { for (size_t i = 0, ed = v.size(); i < ed; ++i) { os << v[i]; if (i + 1 != ed) std::cout << '\n'; } iroha os; }
    template <typename T, const size_t n> std::ostream &operator<<(std::ostream &os, std::vector<std::array<T, n>> &v) { for (size_t i = 0, ed = v.size(); i < ed; ++i) { os << v[i]; if (i + 1 != ed) std::cout << '\n'; } iroha os;}
    template <typename... Args> void IN(Args&... any) { ((std::cin >> any), ...); }
    inline void U() {} template <typename... Args> inline void U(Args&&... any) { ((std::cout << any), ...); }
    inline void UU() { std::cout << " "; } template <typename... Args> inline void UU(Args&&... any) { ((std::cout << any << " "), ...); }
    inline void UL() { std::cout << "\n"; } template <typename... Args> inline void UL(Args&&... any) { ((std::cout << any << "\n"), ...); }
    template <typename T, typename S> inline void Uif(bool ok, T a, S b) { std::cout << (ok ? a : b); }
    inline void YES(bool ok) { UL(ok ? "YES" : "NO"); } inline void Yes(bool ok) { UL(ok ? "Yes" : "No"); } inline void yes(bool ok) { UL(ok ? "yes" : "no"); }
    inline void NO(bool ok)  { UL(ok ? "NO" : "YES"); } inline void No(bool ok)  { UL(ok ? "No" : "Yes"); } inline void no(bool ok)  { UL(ok ? "no" : "yes"); }
    inline void ALICE(bool ok) { UL(ok ? "ALICE" : "BOB"); } inline void Alice(bool ok) { UL(ok ? "Alice" : "Bob"); } inline void alice(bool ok) { UL(ok ? "alice" : "bob"); }
    inline void BOB(bool ok) { UL(ok ? "BOB" : "ALICE"); } inline void Bob(bool ok) { UL(ok ? "Bob" : "Alice"); } inline void bob(bool ok) { UL(ok ? "bob" : "alice"); }
    inline void POSSIBLE(bool ok) { UL(ok ? "POSSIBLE" : "IMPOSSIBLE"); } inline void Possible(bool ok) { UL(ok ? "Possible" : "Impossible"); } inline void possible(bool ok) { UL(ok ? "possible" : "impossible"); }
    inline void IMPOSSIBLE(bool ok) { UL(not ok ? "POSSIBLE" : "IMPOSSIBLE"); } inline void Impossible(bool ok) { UL(not ok ? "Possible" : "Impossible"); } inline void impossible(bool ok) { UL(not ok ? "possible" : "impossible"); }
} using namespace MeIoN_IO;
void pre_work() {
    //          /*  MeIoN_is_UMP45  */          codeforces id
    //              /*  MeIoN  */               luogu / atcoder id
    // https://space.bilibili.com/285769347     My bilibili
    // https://www.cnblogs.com/guidingstar      My blog
    //             /* 604223110 */              QQ

    // freopen(".in","r",stdin);
    // freopen("z_res.out","w",stdout);

    std::cout << std::fixed << std::setprecision(12);
}
// #define guidingstar
// #define tests
namespace internal {
    template <class E>
    struct csr {
        std::vector<int> start;
        std::vector<E> elist;
        explicit csr(int n, const std::vector<std::pair<int, E>>& edges)
                : start(n + 1), elist(edges.size()) {
            for (auto e: edges) { start[e.first + 1]++; }
            for (int i = 1; i <= n; i++) { start[i] += start[i - 1]; }
            auto counter = start;
            for (auto e: edges) { elist[counter[e.first]++] = e.second; }
        }
    };

    template <class T>
    struct simple_queue {
        std::vector<T> payload;
        int pos = 0;
        void reserve(int n) { payload.reserve(n); }
        int size() const { return int(payload.size()) - pos; }
        bool empty() const { return pos == int(payload.size()); }
        void push(const T& t) { payload.push_back(t); }
        T& front() { return payload[pos]; }
        void clear() {
            payload.clear();
            pos = 0;
        }
        void pop() { pos++; }
    };
} // namespace internal
template <class Cap = int, class Cost = ll, bool DAG = false>
struct mcf_graph {
public:
    mcf_graph() {}
    explicit mcf_graph(int n) : _n(n) {}
    // frm, to, cap, cost
    int add(int frm, int to, Cap cap, Cost cost) {
//        assert(0 <= frm && frm < _n), assert(0 <= to && to < _n), assert(0 <= cap), assert(DAG || 0 <= cost);
        if (DAG) assert(frm < to);
        int m = int(_edges.size());
        _edges.push_back({frm, to, cap, 0, cost});
        return m;
    }
    // void debug() {
    //     std::cout << "flow graph\n";
    //     std::cout << "frm, to, cap, cost\n";
    //     for (auto&& [frm, to, cap, flow, cost]: _edges) std::cout << (frm, to, cap, cost);
    // }
    struct edge {
        int frm, to;
        Cap cap, flow;
        Cost cost;
    };
    edge get_edge(int i) {
        int m = int(_edges.size());
        assert(0 <= i && i < m);
        return _edges[i];
    }
    std::vector<edge> edges() { return _edges; }

    // (流量, 費用)
    std::pair<Cap, Cost> flow(int s, int t) {
        return flow(s, t, std::numeric_limits<Cap>::max());
    }
    // (流量, 費用)
    std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
        return slope(s, t, flow_limit).back();
    }
    std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
        return slope(s, t, std::numeric_limits<Cap>::max());
    }
    std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
        assert(0 <= s && s < _n), assert(0 <= t && t < _n), assert(s != t);
        int m = int(_edges.size());
        std::vector<int> edge_idx(m);
        auto g = [&]() {
            std::vector<int> degree(_n), redge_idx(m);
            std::vector<std::pair<int, _edge>> elist;
            elist.reserve(2 * m);
            for (int i = 0; i < m; i++) {
                auto e = _edges[i];
                edge_idx[i] = degree[e.frm]++;
                redge_idx[i] = degree[e.to]++;
                elist.push_back({e.frm, {e.to, -1, e.cap - e.flow, e.cost}});
                elist.push_back({e.to, {e.frm, -1, e.flow, -e.cost}});
            }
            auto _g = internal::csr<_edge>(_n, elist);
            for (int i = 0; i < m; i++) {
                auto e = _edges[i];
                edge_idx[i] += _g.start[e.frm];
                redge_idx[i] += _g.start[e.to];
                _g.elist[edge_idx[i]].rev = redge_idx[i];
                _g.elist[redge_idx[i]].rev = edge_idx[i];
            }
            return _g;
        }();
        auto result = slope(g, s, t, flow_limit);
        for (int i = 0; i < m; i++) {
            auto e = g.elist[edge_idx[i]];
            _edges[i].flow = _edges[i].cap - e.cap;
        }
        return result;
    }

private:
    int _n;
    std::vector<edge> _edges;
    // inside edge
    struct _edge {
        int to, rev;
        Cap cap;
        Cost cost;
    };
    std::vector<std::pair<Cap, Cost>> slope(internal::csr<_edge>& g, int s, int t, Cap flow_limit) {
        // variants (C = maxcost):
        // -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
        // reduced cost (= e.cost + dual[e.frm] - dual[e.to]) >= 0 for all edge

        // dual_dist[i] = (dual[i], dist[i])
        if (DAG) assert(s == 0 && t == _n - 1);
        std::vector<std::pair<Cost, Cost>> dual_dist(_n);
        std::vector<int> prev_e(_n);
        std::vector<bool> vis(_n);
        struct Q {
            Cost key;
            int to;
            bool operator<(Q r) const { return key > r.key; }
        };
        std::vector<int> que_min;
        std::vector<Q> que;
        auto dual_ref = [&]() {
            for (int i = 0; i < _n; i++) {
                dual_dist[i].second = std::numeric_limits<Cost>::max();
            }
            std::fill(vis.begin(), vis.end(), false);
            que_min.clear();
            que.clear();

            // que[0..heap_r) was heapified
            size_t heap_r = 0;

            dual_dist[s].second = 0;
            que_min.push_back(s);
            while (!que_min.empty() || !que.empty()) {
                int v;
                if (!que_min.empty()) {
                    v = que_min.back();
                    que_min.pop_back();
                } else {
                    while (heap_r < que.size()) {
                        heap_r++;
                        std::push_heap(que.begin(), que.begin() + heap_r);
                    }
                    v = que.front().to;
                    std::pop_heap(que.begin(), que.end());
                    que.pop_back();
                    heap_r--;
                }
                if (vis[v]) continue;
                vis[v] = true;
                if (v == t) break;
                // dist[v] = shortest(s, v) + dual[s] - dual[v]
                // dist[v] >= 0 (all reduced cost are positive)
                // dist[v] <= (n-1)C
                Cost dual_v = dual_dist[v].first, dist_v = dual_dist[v].second;
                for (int i = g.start[v]; i < g.start[v + 1]; i++) {
                    auto e = g.elist[i];
                    if (!e.cap) continue;
                    // |-dual[e.to] + dual[v]| <= (n-1)C
                    // cost <= C - -(n-1)C + 0 = nC
                    Cost cost = e.cost - dual_dist[e.to].first + dual_v;
                    if (dual_dist[e.to].second > dist_v + cost) {
                        Cost dist_to = dist_v + cost;
                        dual_dist[e.to].second = dist_to;
                        prev_e[e.to] = e.rev;
                        if (dist_to == dist_v) {
                            que_min.push_back(e.to);
                        } else {
                            que.push_back(Q{dist_to, e.to});
                        }
                    }
                }
            }
            if (!vis[t]) { return false; }

            for (int v = 0; v < _n; v++) {
                if (!vis[v]) continue;
                // dual[v] = dual[v] - dist[t] + dist[v]
                //         = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
                //         (shortest(s, v) + dual[s] - dual[v]) = - shortest(s,
                //         t) + dual[t] + shortest(s, v) = shortest(s, v) -
                //         shortest(s, t) >= 0 - (n-1)C
                dual_dist[v].first -= dual_dist[t].second - dual_dist[v].second;
            }
            return true;
        };

        auto dual_ref_dag = [&]() {
            for (int i = 0; i < _n; i++) {
                dual_dist[i].second = std::numeric_limits<Cost>::max();
            }
            dual_dist[s].second = 0;
            std::fill(vis.begin(), vis.end(), false);
            vis[0] = true;

            for (int v = 0; v < _n; ++v) {
                if (!vis[v]) continue;
                Cost dual_v = dual_dist[v].first, dist_v = dual_dist[v].second;
                for (int i = g.start[v]; i < g.start[v + 1]; i++) {
                    auto e = g.elist[i];
                    if (!e.cap) continue;
                    Cost cost = e.cost - dual_dist[e.to].first + dual_v;
                    if (dual_dist[e.to].second > dist_v + cost) {
                        vis[e.to] = true;
                        Cost dist_to = dist_v + cost;
                        dual_dist[e.to].second = dist_to;
                        prev_e[e.to] = e.rev;
                    }
                }
            }
            if (!vis[t]) { return false; }

            for (int v = 0; v < _n; v++) {
                if (!vis[v]) continue;
                // dual[v] = dual[v] - dist[t] + dist[v]
                //         = dual[v] - (shortest(s, t) + dual[s] - dual[t]) +
                //         (shortest(s, v) + dual[s] - dual[v]) = - shortest(s,
                //         t) + dual[t] + shortest(s, v) = shortest(s, v) -
                //         shortest(s, t) >= 0 - (n-1)C
                dual_dist[v].first -= dual_dist[t].second - dual_dist[v].second;
            }
            return true;
        };

        Cap flow = 0;
        Cost cost = 0, prev_cost_per_flow = -1;
        std::vector<std::pair<Cap, Cost>> result = {{Cap(0), Cost(0)}};
        while (flow < flow_limit) {
            if (DAG && flow == 0) {
                if (!dual_ref_dag()) break;
            } else {
                if (!dual_ref()) break;
            }
            Cap c = flow_limit - flow;
            for (int v = t; v != s; v = g.elist[prev_e[v]].to) {
                c = std::min(c, g.elist[g.elist[prev_e[v]].rev].cap);
            }
            for (int v = t; v != s; v = g.elist[prev_e[v]].to) {
                auto& e = g.elist[prev_e[v]];
                e.cap += c;
                g.elist[e.rev].cap -= c;
            }
            Cost d = -dual_dist[s].first;
            flow += c;
            cost += c * d;
            if (prev_cost_per_flow == d) { result.pop_back(); }
            result.push_back({flow, cost});
            prev_cost_per_flow = d;
        }
        return result;
    }
};

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> a[i].first;
    }
    for(int i = 1; i <= n; i++) {
        cin >> a[i].second;
    }
    for(int i = 1; i <= n; i++) {
        cin >> b[i];
    }
    for(int i = 1; i <= n; i++) {
        cin >> c[i];
    }

    sort(a + 1, a + 1 + n);
    for(int i = 1; i <= n; i++) {
        sum[i] = sum[i - 1] + a[i].second;
    }

    int s = n + n + 1, t = s + 1;
    mcf_graph g(2 * n + 3);
    for(int i = 1; i <= n; i++) {
        g.add(s, i, 1, 0);
        g.add(i + n, t, 1, 0);
    }

    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            int l = 0, r = n;
            while(l < r) {
                int mid = (l + r + 1) >> 1;
                if(a[mid].first >= b[i] + c[j]) {
                    r = mid - 1;
                } else {
                    l = mid;
                }
            }
            g.add(i, n + j, 1, -sum[l]);
        }
    }

    cout << -g.flow(s, t).second << '\n';
    return 0;
}