#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second
 
typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const LL LINF = 1e18;

struct Graph
{
	struct Edge
	{
		int from, to;
		LL cap, flow;
	};
	int n;
	vector<Edge> edges;
	vector<VI> g;
	VI d, p;
	void init(int _n)
	{
		n = _n;
		edges.clear();
		g.clear();
		g.resize(n);
		d.resize(n);
		p.resize(n);
	}
	void addEdge(int from, int to, LL cap)
	{
		assert(0 <= from && from < n);
		assert(0 <= to && to < n);
		assert(0 <= cap);
		g[from].PB(SZ(edges));
		edges.PB({from, to, cap, 0});
		g[to].PB(SZ(edges));
		edges.PB({to, from, 0, 0});
	}
	int bfs(int s, int t)
	{
		fill(ALL(d), -1);
		d[s] = 0;
		queue<int> q;
		q.push(s);
		while (!q.empty())
		{
			int v = q.front();
			q.pop();
			for (int e : g[v])
			{
				int to = edges[e].to;
				if (edges[e].flow < edges[e].cap && d[to] == -1)
				{
					d[to] = d[v] + 1;
					q.push(to);
				}
			}
		}
		return d[t];
	}
	LL dfs(int v, int t, LL flow)
	{
		if (v == t || flow == 0)
			return flow;
		for (; p[v] < SZ(g[v]); p[v]++)
		{
			int e = g[v][p[v]], to = edges[e].to;
			LL c = edges[e].cap, f = edges[e].flow;
			if (f < c && (to == t || d[to] == d[v] + 1))
			{
				LL push = dfs(to, t, min(flow, c - f));
				if (push > 0)
				{
					edges[e].flow += push;
					edges[e ^ 1].flow -= push;
					return push;
				}
			}
		}
		return 0;
	}
	LL flow(int s, int t)
	{
		assert(0 <= s && s < n);
		assert(0 <= t && t < n);
		assert(s != t);
		LL flow = 0;
		while (bfs(s, t) != -1)
		{
			fill(ALL(p), 0);
			while (true)
			{
				LL f = dfs(s, t, LINF);
				if (f == 0)
					break;
				flow += f;
			}
		}
		return flow;
	}
};

int Flow(int n, int m, const VI& a, const vector<VI>& g)
{
	Graph G;
	G.init(n + m + 2);
	int s = n + m;
	int t = s + 1;
	FOR (i, 0, m)
	{
		G.addEdge(s, i, a[i]);
		for (int to : g[i])
			G.addEdge(i, to + m, 1);
	}
	FOR (i, 0, n)
		G.addEdge(i + m, t, 1);
	return G.flow(s, t);
}

void solve()
{
	int n, m;
	cin >> n >> m;
	VI a(m), b(m), c(m);
	vector<VI> g(m);
	int res = 0;
	FOR(i, 0, m)
	{
		cin >> a[i] >> b[i] >> c[i];
		res += b[i] + c[i];
		b[i] *= 2;
		int t;
		cin >> t;
		g[i].resize(t);
		for (int& x : g[i])
		{
			cin >> x;
			x--;
		}
	}
	FOR (i, 0, m)
		a[i] += b[i] + c[i];
	if (Flow(n, m, a, g) != n)
	{
		cout << "-1\n";
		return;
	}
	FOR(i, 0, m)
		a[i] -= b[i] + c[i];
	VI vec(m);
	iota(ALL(vec), 0);
	mt19937 rng;
	VI sa = a, sb = b;
	int maxAns = 0;
	FOR(it, 0, 20)
	{
		a = sa;
		b = sb;
		shuffle(ALL(vec), rng);
		int ans = 0;
		int f = Flow(n, m, a, g);
		for (int i : vec)
		{
			a[i] += b[i];
			int nf = Flow(n, m, a, g);
			int x = nf - f;
			x -= x % 2;
			a[i] -= b[i];
			a[i] += x;
			b[i] -= x;
			f += x;
			ans += x / 2;
		}
		ans += n - f;
		maxAns = max(maxAns, res - ans);
	}
	cout << maxAns << '\n';
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int t;
	cin >> t;
	while (t--)
	{
		solve();
	}
	return 0;
}