import java.lang.RuntimeException
import java.util.*

data class Edge(val from: Int, val to: Int, val capacity: Int, val cost: Long) {
  var resCapacity = capacity
  var resCost = cost
  var revEdge: Edge? = null
}

const val M = 10000000000L

fun main(args: Array<String>) {
  val n = readLine()!!.toInt()
  val edges = mutableListOf<Edge>()
  val s = 2 * n
  val t = 2 * n + 1
  val m1 = 2 * n + 2
  val m2 = 2 * n + 3
  val m3 = 2 * n + 4
  val m4 = 2 * n + 5
  var volume = 0
  repeat(n) {
    val v = it
    val (xInt, yInt, c) = readLine()!!.split(" ").map(String::toInt)
    volume += c
    val x = xInt.toLong()
    val y = yInt.toLong()
    edges.add(Edge(s, v, c, 0))
    edges.add(Edge(v, m1, c, M - (x + y)))
    edges.add(Edge(v, m2, c, M - (x - y)))
    edges.add(Edge(v, m3, c, M - (-x + y)))
    edges.add(Edge(v, m4, c, M - (-x - y)))
  }
  repeat(n) {
    val v = n + it
    val (xInt, yInt, c) = readLine()!!.split(" ").map(String::toInt)
    val x = xInt.toLong()
    val y = yInt.toLong()
    edges.add(Edge(m1, v, c, M - (-x - y)))
    edges.add(Edge(m2, v, c, M - (-x + y)))
    edges.add(Edge(m3, v, c, M - (x - y)))
    edges.add(Edge(m4, v, c, M - (x + y)))
    edges.add(Edge(v, t, c, 0))
  }
  val graph = buildMinCostFlowGraph(2 * n + 6, edges)
  val (flow, cost) = minCostFlow(2 * n + 6, graph, s, t, volume)
  if (flow != volume) throw RuntimeException()
  println(2 * M * volume - cost)
}

fun buildMinCostFlowGraph(n : Int, edges: List<Edge>): List<List<Edge>> {
  val mutableGraph = Array(n, { mutableListOf<Edge>() })
  for (edge in edges) {
    val revEdge = Edge(edge.to, edge.from, 0, -edge.cost)
    edge.revEdge = revEdge
    revEdge.revEdge = edge
    mutableGraph[edge.from].add(edge)
    mutableGraph[revEdge.from].add(revEdge)
  }
  return mutableGraph.map { it.toList() }
}

// Solves a minimum cost flow problem by primal-dual algorithm.
// Complexity: O(B E log V) (B is the volume of flow)
//
// Constraints:
// - There should be no negative cost edges in the initial network.
// - The reverse edges are set in the graph.
//
// Returns a pair of (actual flow volume, cost).
//
// Verified: AOJ-GRL6B, AGC034D
fun minCostFlow(n: Int, graph: List<List<Edge>>,
                s: Int, t: Int, b: Int): Pair<Int, Long> {
  data class DState(var v: Int, var prevEdge: Edge?, var weight: Long) {
    fun reset(v: Int, prevEdge: Edge?, weight: Long) {
      this.v = v
      this.prevEdge = prevEdge
      this.weight = weight
    }
  }

  class DStatePool() {
    private val garbagePool = ArrayDeque<DState>()

    fun make(v: Int, prevEdge: Edge?, weight: Long): DState {
      if (garbagePool.isNotEmpty()) {
        val dState = garbagePool.pollLast()!!
        dState.reset(v, prevEdge, weight)
        return dState
      } else {
        return DState(v, prevEdge, weight)
      }
    }

    fun collect(dState: DState) {
      garbagePool.offerLast(dState)
    }
  }

  val dStatePool = DStatePool()

  val INF = Long.MAX_VALUE / 4
  var flow = 0
  var flowCost = 0L
  val dists = LongArray(n)
  val usedEdges = Array<Edge?>(n, { null })
  val pq = PriorityQueue(
      n,
      Comparator<DState> { s1, s2 -> java.lang.Long.compare(s1.weight, s2.weight) })
  val pathEdges = mutableListOf<Edge>()
  while (flow < b) {
    dists.fill(INF)
    usedEdges.fill(null)
    pq.clear()
    pq.add(dStatePool.make(s, null, 0))
    // pq.add(DState(s, null, 0))
    dists[s] = 0
    while (pq.isNotEmpty()) {
      val state = pq.poll()
      for (e in graph[state.v]) {
        if (e.resCapacity == 0) continue
        // if (dists[e.to] < INF) continue
        val newWeight = state.weight + e.resCost
        if (dists[e.to] <= newWeight) continue
//        pq.add(DState(e.to, e, newWeight))
        pq.add(dStatePool.make(e.to, e, newWeight))
        dists[e.to] = newWeight
        usedEdges[e.to] = e
      }
      dStatePool.collect(state)
    }

    // There is no path to the sink.
    if (dists[t] == INF) break

    pathEdges.clear()
    var currentV = t
    while (usedEdges[currentV] != null) {
      pathEdges.add(usedEdges[currentV]!!)
      currentV = usedEdges[currentV]!!.from
    }

    var inc = b - flow
    for (e in pathEdges) {
      inc = Math.min(inc, e.resCapacity)
    }

    flow += inc

    for (e in pathEdges) {
      e.resCapacity -= inc
      e.revEdge!!.resCapacity += inc
      flowCost += inc * e.cost
    }

    for (v in 0 until n) {
      for (e in graph[v]) {
        e.resCost += dists[e.from] - dists[e.to]
      }
    }
  }
  return Pair(flow, flowCost)
}


Measured memory_bytes: 118256