/*
 不, 我想亲眼看看自己选择的终点是什么样的地方.
 */
#include <cmath>
#include <cstring>

#include <algorithm>
#include <limits>
#include <functional>
#include <random>
#include <chrono>
#include <stack>
#include <bitset>
#include <numeric>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <map>
#include <unordered_map>

using ull = unsigned long long;
using ll = long long;

using namespace std;

mt19937 rng(chrono::steady_clock().now().time_since_epoch().count());

const int P = 998244353;

int norm(int x) { return x >= P ? x - P : x; }
int reduce(int x) { return x < 0 ? x + P : x; }
int neg(int x) { return x ? P - x : 0; }
void add(int& x, int y) { if ((x += y - P) < 0) x += P; }
void sub(int& x, int y) { if ((x -= y) < 0) x += P; }
void fam(int& x, int y, int z) { x = (x + y * (ull)z) % P; }
int mpow(int x, unsigned k) {
	if (k == 0) return 1;
	int ret = mpow(x * (ull)x % P, k >> 1);
	if (k & 1) ret = ret * (ull)x % P;
	return ret;
}

template<class Z>
struct MaxFlow {
  vector<vector<tuple<int, int, Z>>> g;
 
  struct Ref {
    const MaxFlow *p;
    int u, id;
 
    Ref() {}
 
    Ref(const MaxFlow *p, int u, int id) : p(p), u(u), id(id) {}
 
    Z get() const { return std::get<2>((p->g)[u][id]); }
  };
 
  MaxFlow() {}
 
  MaxFlow(int n) : g(n) {}
 
  Ref addEdge(int u, int v, const Z &w) {
    if (u == v) return Ref();
    int ru = g[u].size(), rv = g[v].size();
    g[u].emplace_back(v, rv, w);
    g[v].emplace_back(u, ru, 0);
    return Ref(this, v, rv);
  }
 
  Z dinic(int s, int t) {
    int n = g.size();
    function<vector<int>()> getLevel = [&]() {
      vector<int> level(n, -1);
      queue<int> q;
      level[s] = 0;
      q.push(s);
      while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (const auto &pr : g[u])
          if (get<2>(pr) && level[get<0>(pr)] == -1) {
            level[get<0>(pr)] = level[u] + 1;
            q.push(get<0>(pr));
          }
      }
      return level;
    };
    vector<int> r, level;
    function<Z(int, Z)> cap = [&](int u, Z limit) {
      if (u == t) return limit;
      Z ret = 0;
      while (r[u] && limit > ret) {
        int v = get<0>(g[u][r[u] - 1]), rev = get<1>(g[u][r[u] - 1]);
        Z &w = get<2>(g[u][r[u] - 1]);
        if (level[v] == level[u] + 1) {
          Z flow = cap(v, min(limit - ret, w));
          ret += flow;
          w -= flow;
          get<2>(g[v][rev]) += flow;
          if (limit == ret)
            return ret;
          --r[u];
        } else
          --r[u];
      }
      return ret;
    };
    Z ret = 0;
    while (level = getLevel(), level[t] != -1) {
      r = vector<int>(n);
      for (int i = 0; i < n; ++i)
        r[i] = g[i].size();
      ret += cap(s, numeric_limits<Z>::max());
    }
    return ret;
  }
};

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr); cout.tie(nullptr);

	int N, M; cin >> N >> M;
	MaxFlow<long long> flow(N * 3 + 2);
	int s = N * 3, t = s + 1;
	for (int i = 0; i != N * 2; ++i) {
		int c, d, e; cin >> c >> d >> e;
		flow.addEdge(s, i, c); flow.addEdge(i, t, d);
		flow.addEdge(i ^ 1, i, e);
	}
	for (int i = 0; i != N; ++i) {
		flow.addEdge(i * 2, N * 2 + i, 1e18);
		flow.addEdge(i * 2 + 1, N * 2 + i, 1e18);
	}
	while (M--) {
		int A, B, a, b; cin >> A >> B >> a >> b; --A; --B;
		flow.addEdge(N * 2 + A / 2, B, a);
		flow.addEdge(A, N * 2 + B / 2, b);
	}
	cout << flow.dinic(s, t) << '\n';

	return 0;
}