#ifndef MAJK_LIB
#define MAJK_LIB

#include <vector>
#include <stack>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <iomanip>
#include <set>
#include <functional>
#include <fstream>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <string>
#include <sstream>
#include <queue>
#include <array>
#include <bitset>
using namespace std;

#define x first
#define y second
typedef std::pair<int, int> pii; typedef long long ll; typedef unsigned long long ull; typedef unsigned int ui; typedef pair<ui, ui> puu;

template <typename T, typename U> std::istream&operator>>(std::istream&i, pair<T, U>&p) {
    i >> p.x >> p.y;
    return i;
}
template<typename T>std::istream&operator>>(std::istream&i, vector<T>&t) {
    for (auto&v : t)i >> v;
    return i;
}
template <typename T, typename U> std::ostream&operator<<(std::ostream&o, const pair<T, U>&p) {
    o << p.x << ' ' << p.y;
    return o;
}
template<typename T>std::ostream&operator<<(std::ostream&o, const vector<T>&t) {
    if (t.empty())o << '\n';
    for (size_t i = 0; i < t.size(); ++i)o << t[i] << " \n"[i == t.size() - 1];
    return o;
}
template<typename T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template<typename T> using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T> bool in(T a, T b, T c) {
    return a <= b && b < c;
}
ui logceil(ll x) {
    return x ? 8 * sizeof(ll) - __builtin_clzll(x) : 0;
}

namespace std {
    template<typename T, typename U>struct hash<pair<T, U>> {
        hash<T>t;
        hash<U>u;
        size_t operator()(const pair<T, U>&p)const {
            return t(p.x) ^ (u(p.y) << 7);
        }
    };
}
template<typename T, typename F>T bsh(T l, T h, const F&f) {
    T r = -1, m;
    while (l <= h) {
        m = (l + h) / 2;
        if (f(m)) {
            l = m + 1;
            r = m;
        }
        else h = m - 1;
    } return r;
}
template<typename F> double bshd(double l, double h, const F&f, double p = 1e-9) {
    ui r = 3 + (ui)log2((h - l) / p);
    while (r--) {
        double m = (l + h) / 2;
        if (f(m))l = m;
        else h = m;
    } return (l + h) / 2;
}
template<typename T, typename F>T bsl(T l, T h, const F&f) {
    T r = -1, m;
    while (l <= h) {
        m = (l + h) / 2;
        if (f(m)) {
            h = m - 1;
            r = m;
        }
        else l = m + 1;
    } return r;
}
template<typename F> double bsld(double l, double h, const F&f, double p = 1e-9) {
    ui r = 3 + (ui)log2((h - l) / p);
    while (r--) {
        double m = (l + h) / 2;
        if (f(m))h = m;
        else l = m;
    } return (l + h) / 2;
}
template<typename T> T gcd(T a, T b) {
    if (a < b) swap(a, b);
    return b ? gcd(b, a % b) : a;
}


template<typename T>class vector2: public vector<vector<T>> {
public: vector2() {} vector2(size_t a, size_t b, T t = T()): vector<vector<T>>(a, vector<T>(b, t)) {}
};
template<typename T>class vector3: public vector<vector2<T>> {
public: vector3() {} vector3(size_t a, size_t b, size_t c, T t = T()): vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template<typename T>class vector4: public vector<vector3<T>> {
public: vector4() {} vector4(size_t a, size_t b, size_t c, size_t d, T t = T()): vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template<typename T>class vector5: public vector<vector4<T>> {
public: vector5() {} vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T()): vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};


#endif

const ll inf = 1e18;
struct FFFF {
	#define NN 3030
	#define M 30000
	ll n, tot, src, dst;
	ll a[M], b[M], c[M], d[M];
	ll fst[NN], nxt[M], prv[NN];
	ll cst[NN];
	ll chk[NN];

	queue <ll> q;

	void init(ll _n) {
		n = _n;
		tot = 0;
		fill_n(fst, n, -1);
	}
	void add_edge(ll from, ll to, ll cap, ll cost) {
		a[tot] = from, b[tot] = to, c[tot] = cap, d[tot] = cost;
		nxt[tot] = fst[from], fst[from] = tot ++;
		a[tot] = to, b[tot] = from, c[tot] = 0, d[tot] = - cost;
		nxt[tot] = fst[to], fst[to] = tot++;
	}
	typedef pair <ll, ll> pii;

	pii solve(ll _src, ll _dst) {
		src = _src, dst = _dst;
		ll e, u, v;
		ll inc, flow;
		ll cost;
		flow = cost = 0;
		while (1) {
			fill_n(cst, n, inf);
			cst[src] = 0;
			chk[src]++;
			q.push(src);
			while (!q.empty()) {
				u = q.front();
				q.pop();
				chk[u]--;
				for (e = fst[u]; ~e; e = nxt[e]) {
					v = b[e];
					if (!c[e] || cst[v] <= cst[u] + d[e]) continue;
					cst[v] = cst[u] + d[e];
					prv[v] = e;
					if (!chk[v]) {
						chk[v]++;
						q.push(v);
					}
				}
			}
			if (cst[dst] == inf) break;
			inc = inf;
			for (v = dst; v != src; v = a[e]) {
				e = prv[v];
				inc = min(inc, c[e]);
			}
			flow += inc;
			cost += cst[dst] * inc;
			for (v = dst; v != src; v = a[e]) {
				e = prv[v];
				c[e] -= inc, c[e ^ 1] += inc;
			}
		}
		return pii(flow, cost);
	}
} G;


class DManhattanMaxMatching {
public:
    void solve(istream& cin, ostream& cout) {
        int N; cin >> N;
        G.init(2 * N + 15);
        for (int i = 0; i < N; ++i) {
            int x, y, c; cin >> x >> y >> c;
            G.add_edge(2 * N, i, c, 0);
            G.add_edge(i, 2 * N + 1, c, x + y);
            G.add_edge(i, 2 * N + 2, c, x - y);
            G.add_edge(i, 2 * N + 3, c, -x + y);
            G.add_edge(i, 2 * N + 4, c, -x - y);
        }
        for (int i = 0; i < N; ++i) {
            int x, y, c; cin >> x >> y >> c;
            G.add_edge(N + i, 2 * N + 9, c, 0);
            G.add_edge(2 * N + 5, N + i, c, x + y);
            G.add_edge(2 * N + 6, N + i, c, x - y);
            G.add_edge(2 * N + 7, N + i, c, -x + y);
            G.add_edge(2 * N + 8, N + i, c, -x - y);
        }
        G.add_edge(2 * N + 1, 2 * N + 8, 10000, 0);
        G.add_edge(2 * N + 2, 2 * N + 7, 10000, 0);
        G.add_edge(2 * N + 3, 2 * N + 6, 10000, 0);
        G.add_edge(2 * N + 4, 2 * N + 5, 10000, 0);
        auto g = G.solve(2 * N, 2 * N + 9);
        cout << -g.y << endl;
    }
};


int main() {
    ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
    DManhattanMaxMatching solver;
    std::istream& in(std::cin);
    std::ostream& out(std::cout);
    solver.solve(in, out);
    return 0;
}


Measured memory_bytes: 1152