// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



const int N = 3010;



typedef long long LL;



struct edge {

    int to, next, w, c;

} e[N * 10];



int head[N], ecnt = 1;



inline void adde(int from, int to, int w, int c) {

    e[++ecnt] = (edge){to, head[from], w, -c}, head[from] = ecnt;

    e[++ecnt] = (edge){from, head[to], 0, c}, head[to] = ecnt;

}



int vis[N], cur[N]; LL dis[N];



inline bool SPFA(int s, int t) {

    memset(dis, 0x3f, sizeof(dis)), memset(vis, 0, sizeof(vis));

    queue<int> q; q.push(t), vis[t] = 1, dis[t] = 0;

    while (!q.empty()) {

        int u = q.front(); q.pop(), vis[u] = 0;

        for (int i = head[u]; i; i = e[i].next)

            if (e[i ^ 1].w && dis[e[i].to] > dis[u] - e[i].c) {

                dis[e[i].to] = dis[u] - e[i].c;

                if (!vis[e[i].to]) q.push(e[i].to), vis[e[i].to] = 1;

            }

    }

    return dis[s] < 1e17;

}



LL ans;



int DFS(int u, int t, int f) {

    if (u == t || !f) return f;

    int res = 0; vis[u] = 1;

    for (int &i = cur[u], tmp; i; i = e[i].next)

        if (!vis[e[i].to] && e[i].w && dis[u] - e[i].c == dis[e[i].to] && 

            (tmp = DFS(e[i].to, t, min(f, e[i].w)))) {

                res += tmp, f -= tmp, e[i].w -= tmp, e[i ^ 1].w += tmp, ans += (LL)tmp * e[i].c;

                if (!f) break;

            }

    return res;

}



inline LL dinic(int s, int t) {

    while (SPFA(s, t)) memcpy(cur, head, sizeof(head)), DFS(s, t, 1e9);

    return ans;

}



int main() {

    int n, s, t; scanf("%d", &n), s = n * 2 + 5, t = s + 1;

    for (int i = 1; i <= n; i++) {

        int x, y, c; scanf("%d%d%d", &x, &y, &c);

        adde(s, i, c, 0);

        adde(i, 2 * n + 1, 1e9, -x - y), adde(i, 2 * n + 2, 1e9, x + y);

        adde(i, 2 * n + 3, 1e9, y - x), adde(i, 2 * n + 4, 1e9, x - y);

    }

    for (int i = 1; i <= n; i++) {

        int x, y, c; scanf("%d%d%d", &x, &y, &c);

        adde(i + n, t, c, 0);

        adde(2 * n + 1, i + n, 1e9, x + y), adde(2 * n + 2, i + n, 1e9, -x - y);

        adde(2 * n + 3, i + n, 1e9, x - y), adde(2 * n + 4, i + n, 1e9, y - x);

    }

    printf("%lld\n", -dinic(s, t));

    return 0;

}//

// Faster C++ solution for the same problem (measured speedup: 1.2042161212712919x):
#include <cstdio>

#include <iostream>

#include <queue>

#include <cstring>

using namespace std;

typedef long long ll;

const int maxn = 2000,maxm = 20005;

const ll inf = 1e11;



struct Edge{

    Edge() {}

    Edge(int a,int b,ll c,int d){v = a;f = b;w = c;nxt = d;}

    int v,f,w,nxt;

};



int n,lmt;

int g[maxn + 10];

Edge e[maxm + 10];

int nume = 1;

int src,sink;



void addedge(int u,int v,int c,ll w){

    e[++nume] = Edge(v,c,w,g[u]);

    g[u] = nume;

    e[++nume] = Edge(u,0,-w,g[v]);

    g[v] = nume;

}



queue<int> que;

bool inq[maxn + 10];

ll dist[maxn + 10];

int prv[maxn + 10],pree[maxn + 10];



bool findpath(){

    while(!que.empty()) que.pop();

    que.push(src);

    memset(dist,63,sizeof dist);

    //for(int i = 0;i < maxn; ++i) dist[i] = inf;

    dist[src] = 0;

    inq[src] = true;

    while(!que.empty()){

        int u = que.front();que.pop();

        for(int i = g[u];i;i = e[i].nxt){

            if(e[i].f > 0 && dist[u] + e[i].w < dist[e[i].v]){

                dist[e[i].v] = dist[u] + e[i].w;

                prv[e[i].v] = u;

                pree[e[i].v] = i;

                if(!inq[e[i].v]){

                    inq[e[i].v] = true;

                    que.push(e[i].v);

                }

            }

        }

        inq[u] = false;

    }

    if(dist[sink] < inf) return true;

    else return false;

}



ll augment(){

    int u = sink;

    ll delta = inf;

    while(u != src){

        if(e[pree[u]].f < delta) delta = e[pree[u]].f;

        u = prv[u];

    }

    u = sink;

    while(u != src){

        e[pree[u]].f -= delta;

        e[pree[u] ^ 1].f += delta;

        u = prv[u];

    }

    return dist[sink] * delta;

}



ll mincostflow(){

    ll cur = 0,ans = 0;

    while(findpath()){

        cur += augment();

        if(cur < ans) ans = cur;

    }

    return ans;

}



int main(){

    scanf("%d",&n);

    src = 2 * n + 1,sink = 2 * n + 2;

    for(int i = 1;i <= n; ++i){

        int x,y,c;scanf("%d%d%d",&x,&y,&c);

        addedge(2 * n + 1,i,c,0);

        addedge(i,2 * n + 3,c,x + y);

        addedge(i,2 * n + 4,c,x - y);

        addedge(i,2 * n + 5,c,-x + y);

        addedge(i,2 * n + 6,c,-x - y);

    }

    for(int i = 1;i <= n; ++i){

        int x,y,c;scanf("%d%d%d",&x,&y,&c);

        addedge(n + i,2 * n + 2,c,0);

        addedge(2 * n + 3,n + i,c,-x - y);

        addedge(2 * n + 4,n + i,c,-x + y);

        addedge(2 * n + 5,n + i,c,x - y);

        addedge(2 * n + 6,n + i,c,x + y);

    }



    ll res = mincostflow();

    printf("%lld",-res);

    return 0;

}