#include<bits/stdc++.h>
#define ioclear std::ios::sync_with_stdio(false);std::cin.tie(nullptr);std::cout.tie(nullptr);
#define endl '\n'
//#define int long long

using i64 = long long;

template<typename T> 
struct Flow
{
	static constexpr T inf = 1E17;
	static constexpr int mmax = 1E6 + 10;
	int n, m, s, t;
	T dis[mmax], ptr[mmax];
    Flow(int _n, int _m, int _s, int _t) : n(_n), m(_m), s(_s), t(_t) {}
	Flow() {}
	struct node
	{
		int from, to;
		T cap, flow;
		node() {}
		node(int u, int v, T w, T f) : from(u), to(v), cap(w), flow(f) {}
	};
	std::vector<node> edge;
	std::vector<int> no[mmax];

	void set(int _n, int _m, int _s, int _t) {n = _n, m = _m, s = _s, t = _t;}

	void add(int u, int v, T w)
	{
		no[u].push_back(edge.size());
		edge.push_back({u, v, w, 0});
		no[v].push_back(edge.size());
		edge.push_back({v, u, 0, 0});
		return;
	}

	bool bfs()
	{
		memset(dis, -1, sizeof dis);
		dis[s] = 0;
		std::queue<int> q;
		q.push(s);
		while(!q.empty())
		{
			int v = q.front();
			q.pop();
			if(v == t) return 1;
			for(auto i : no[v])
			{
				int to = edge[i].to;
				if(dis[to] == -1 && edge[i].flow < edge[i].cap)
					dis[to] = dis[v] + 1, q.push(to);
			}
		}
		return 0;
	}

	T dfs(int cur, T maxf)
	{
		if(maxf <= 0) return 0;
		if(cur == t) return maxf;
		for(;ptr[cur] < no[cur].size();ptr[cur]++)
		{
			int id = no[cur][ptr[cur]], to = edge[id].to;
			if(dis[to] != dis[cur] + 1) continue;
			T pushed = dfs(to, std::min(maxf, edge[id].cap - edge[id].flow) );
			if(pushed)
			{
				edge[id].flow += pushed;
				edge[id ^ 1].flow -= pushed;
				return pushed;
			}
		}
		return 0;
	}

	T dinic()
	{
		T Ans = 0, val;
		while(bfs())
		{
			memset(ptr, 0, sizeof ptr);
			while(val = dfs(s, inf) )
				Ans += val;
		}
		return Ans;
	}
};

int n, m;
Flow<i64> f;
std::map<int, int> mp;

signed main()
{
    #ifdef ONLINE_JUDGE
    ioclear;
    #endif

    std::cin >> n >> m;
    int S = 0, T = 2 * n + m;
    f.set(n, m, S, T);
    for(int i = 1;i <= 2 * n;i++)
    {
        i64 c, d, e;
        std::cin >> c >> d >> e;
        f.add(S, i, c);
        f.add(i, T, d);
        f.add((i & 1) ? i + 1 : i - 1, i, e);
        f.add(i, n + (i + 1) / 2, f.inf);
    }
    for(int i = 1;i <= m;i++)
    {
        i64 A, B, a, b;
        std::cin >> A >> B >> a >> b;
        int ida = n + (A + 1) / 2, idb = n + (B + 1) / 2;
        f.add(ida, B, a);
        f.add(A, idb, b);
    }
    std::cout << f.dinic();
}