//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx")
//#undef LOCAL




#include <algorithm>

#include <array>

#include <bitset>

#include <cassert>

#include <complex>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <map>

#include <numeric>

#include <queue>

#include <set>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <vector>

using namespace std;

using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;



#include <unistd.h>

struct Scanner {
    int fd = -1;
    char line[(1 << 15) + 1];
    size_t st = 0, ed = 0;
    void reread() {
        memmove(line, line + st, ed - st);
        ed -= st;
        st = 0;
        ed += ::read(fd, line + ed, (1 << 15) - ed);
        line[ed] = '\0';
    }
    bool succ() {
        while (true) {
            if (st == ed) {
                reread();
                if (st == ed) return false;
            }
            while (st != ed && isspace(line[st])) st++;
            if (st != ed) break;
        }
        if (ed - st <= 50) {
            bool sep = false;
            for (size_t i = st; i < ed; i++) {
                if (isspace(line[i])) {
                    sep = true;
                    break;
                }
            }
            if (!sep) reread();
        }
        return true;
    }
    template <class T, enable_if_t<is_same<T, string>::value, int> = 0>
    bool read_single(T& ref) {
        if (!succ()) return false;
        while (true) {
            size_t sz = 0;
            while (st + sz < ed && !isspace(line[st + sz])) sz++;
            ref.append(line + st, sz);
            st += sz;
            if (!sz || st != ed) break;
            reread();
        }
        return true;
    }
    template <class T, enable_if_t<is_integral<T>::value>* = nullptr>
    bool read_single(T& ref) {
        if (!succ()) return false;
        bool neg = false;
        if (line[st] == '-') {
            neg = true;
            st++;
        }
        ref = T(0);
        while (isdigit(line[st])) {
            ref = 10 * ref + (line[st++] & 0xf);
        }
        if (neg) ref = -ref;
        return true;
    }
    template <class T> bool read_single(V<T>& ref) {
        for (auto& d : ref) {
            if (!read_single(d)) return false;
        }
        return true;
    }
    void read() {}
    template <class H, class... T> void read(H& h, T&... t) {
        bool f = read_single(h);
        assert(f);
        read(t...);
    }
    int read_unsafe() { return 0; }
    template <class H, class... T> int read_unsafe(H& h, T&... t) {
        bool f = read_single(h);
        if (!f) return 0;
        return 1 + read_unsafe(t...);
    }
    Scanner(FILE* fp) : fd(fileno(fp)) {}
};

struct Printer {
  public:
    template <bool F = false> void write() {}
    template <bool F = false, class H, class... T>
    void write(const H& h, const T&... t) {
        if (F) write_single(' ');
        write_single(h);
        write<true>(t...);
    }
    template <class... T> void writeln(const T&... t) {
        write(t...);
        write_single('\n');
    }

    Printer(FILE* _fp) : fp(_fp) {}
    ~Printer() { flush(); }

  private:
    static constexpr size_t SIZE = 1 << 15;
    FILE* fp;
    char line[SIZE], small[50];
    size_t pos = 0;
    void flush() {
        fwrite(line, 1, pos, fp);
        pos = 0;
    }
    void write_single(const char& val) {
        if (pos == SIZE) flush();
        line[pos++] = val;
    }
    template <class T, enable_if_t<is_integral<T>::value>* = nullptr>
    void write_single(T val) {
        if (pos > (1 << 15) - 50) flush();
        if (val == 0) {
            write_single('0');
            return;
        }
        if (val < 0) {
            write_single('-');
            val = -val; // todo min
        }
        size_t len = 0;
        while (val) {
            small[len++] = char(0x30 | (val % 10));
            val /= 10;
        }
        for (size_t i = 0; i < len; i++) {
            line[pos + i] = small[len - 1 - i];
        }
        pos += len;
    }
    void write_single(__int128 val) {
        if (pos > (1 << 15) - 50) flush();
        if (val == 0) {
            write_single('0');
            return;
        }
        if (val < 0) {
            write_single('-');
            val = -val; // todo min
        }
        size_t len = 0;
        while (val) {
            small[len++] = char(0x30 | (val % 10));
            val /= 10;
        }
        for (size_t i = 0; i < len; i++) {
            line[pos + i] = small[len - 1 - i];
        }
        pos += len;
    }

    void write_single(const string& s) {
        for (char c : s) write_single(c);
    }
    void write_single(const char* s) {
        size_t len = strlen(s);
        for (size_t i = 0; i < len; i++) write_single(s[i]);
    }
    template <class T> void write_single(const V<T>& val) {
        auto n = val.size();
        for (size_t i = 0; i < n; i++) {
            if (i) write_single(' ');
            write_single(val[i]);
        }
    }
};

Scanner sc = Scanner(stdin);
Printer pr = Printer(stdout);

template <class Cap, class Cost> struct MinCostFlow {
    MinCostFlow(int _n) : n(_n), g(_n) {}

    int n;
    struct Edge {
        int to, rev;
        Cap cap;
        Cost cost;
    };

    VV<Edge> g;
    Cost max_cost = 0;

    V<pair<int, int>> pos;
    void add_edge(int from, int to, Cap cap, Cost cost) {
        max_cost = max(max_cost, -cost);
        cost *= n;
        pos.push_back({from, int(g[from].size())});
        g[from].push_back({to, int(g[to].size()), cap, cost});
        g[to].push_back({from, int(g[from].size()) - 1, 0, -cost});
    }

    Cost solve() {
        V<Cost> dual(n);
        Cost eps = n * max_cost + 1;
        auto refine = [&]() {
            // -> eps-optimal
            V<Cap> excess(n);
            auto push = [&](int from, auto& e, Cap cap) {
                excess[from] -= cap;
                excess[e.to] += cap;
                g[e.to][e.rev].cap += cap;
                e.cap -= cap;
            };
            for (int u = 0; u < n; u++) {
                for (auto& e : g[u]) {
                    if (e.cap && e.cost + dual[u] - dual[e.to] < 0) {
                        push(u, e, e.cap);
                    }
                }
            }
            V<bool> actives_on(n);
            V<int> actives;
            for (int i = 0; i < n; i++) {
                if (excess[i] > 0) {
                    actives_on[i] = false;
                    actives.push_back(i);
                }
            }

            while (actives.size()) {
                int u = actives.back();
                actives.pop_back();
                actives_on[u] = false;
                // discharge u
                for (auto& e : g[u]) {
                    if (e.cap && e.cost + dual[u] - dual[e.to] < 0) {
                        // push
                        push(u, e, min(excess[u], e.cap));
                        if (!actives_on[e.to]) {
                            actives.push_back(e.to);
                            actives_on[e.to] = true;
                        }
                        if (excess[u] == 0) {
                            break;
                        }
                    }
                }
                if (excess[u] > 0) {
                    // relabel
                    dual[u] -= eps;
                    actives.push_back(u);
                    actives_on[u] = true;
                }
            }

            eps = 0;
            for (int u = 0; u < n; u++) {
                for (auto& e : g[u]) {
                    if (e.cap) {
                         eps = max(eps, -(e.cost + dual[u] - dual[e.to]));
                    }
                }
            }
        };

        while (eps > 1) {
            // e-optimal -> (e/4)-optimal
            eps = max<Cost>(eps >> 2, 1);
            refine();
        }

        Cost answer = 0;
        for (auto p : pos) {
            auto e = g[p.first][p.second];
            Cap first = e.cap + g[e.to][e.rev].cap;
            answer += (first - e.cap) * e.cost;
        }
        return answer / n;
    }
};

int main() {
    int n;
    sc.read(n);

    MinCostFlow<ll, ll> g(2 * n + 2);
    int sv = 2 * n, tv = 2 * n + 1;
    V<int> rx(n), ry(n), bx(n), by(n);
    for (int i = 0; i < n; i++) {
        int c;
        sc.read(rx[i], ry[i], c);
        g.add_edge(sv, i, c, 0);
    }
    for (int i = 0; i < n; i++) {
        int c;
        sc.read(bx[i], by[i], c);
        g.add_edge(n + i, tv, c, 0);
    }
    g.add_edge(tv, sv, TEN(9), 0);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int di = abs(rx[i] - bx[j]) + abs(ry[i] - by[j]);
            g.add_edge(i, n + j, 10, -di);
        }
    }

    pr.writeln(-g.solve());
    return 0;
}


Measured memory_bytes: 59616