#include <bits/stdc++.h>

using u32 = unsigned int;

struct DSU {
	std::vector<int> f, siz;

	DSU() {}
	DSU(int n) {
		init(n);
	}

	void init(int n) {
		f.resize(n);
		std::iota(f.begin(), f.end(), 0);
		siz.assign(n, 1);
	}

	int find(int x) {
		while (x != f[x]) {
			x = f[x] = f[f[x]];
		}
		return x;
	}

	bool merge(int x, int y) {
		x = find(x), y = find(y);
		if (x == y) {
			return false;
		}
		if (siz[x] < siz[y]) {
			std::swap(x, y);
		}
		f[y] = x;
		siz[x] += siz[y];
		return true;
	}

	bool same(int x, int y) {
		return find(x) == find(y);
	}

	int size(int x) {
		return siz[find(x)];
	}
};

constexpr int P = 1e9 + 7;

struct MInt {
	int x;

	MInt(): x(0) {}
	template<class T>
	MInt(T _x): x((_x % P + P) % P) {}

	template<class T>
	MInt pow(T b) const {
		MInt res = 1;
		for (MInt a = *this; b; a *= a, b >>= 1) {
			if (b & 1) {
				res *= a;
			}
		}
		return res;
	}

	MInt inv() const {
		return pow(P - 2);
	}

	MInt &operator+=(const MInt &b) {
		x += b.x;
		if (x >= P) {
			x -= P;
		}
		return *this;
	}
	MInt &operator-=(const MInt &b) {
		x -= b.x;
		if (x < 0) {
			x += P;
		}
		return *this;
	}
	MInt &operator*=(const MInt &b) {
		x = 1ll * x * b.x % P;
		return *this;
	}
	MInt &operator/=(const MInt &b) {
		return *this *= b.inv();
	}

	friend MInt operator+(const MInt &a, const MInt &b) {
		return MInt(a) += b;
	}
	friend MInt operator-(const MInt &a, const MInt &b) {
		return MInt(a) -= b;
	}
	friend MInt operator*(const MInt &a, const MInt &b) {
		return MInt(a) *= b;
	}
	friend MInt operator/(const MInt &a, const MInt &b) {
		return MInt(a) /= b;
	}
};

void solve() {
	int n, m;
	std::cin >> n >> m;

	std::vector<int> u(m), v(m), w(m);
	for (int i = 0; i < m; i++) {
		std::cin >> u[i] >> v[i] >> w[i];
		u[i]--, v[i]--;
	}

	std::vector<int> o(m);
	std::iota(o.begin(), o.end(), 0);
	std::sort(o.begin(), o.end(), [&](int i, int j) -> bool {
		return w[i] < w[j];
	});

	DSU dsu(n);
	int mst = 0;

	for (int i : o) {
		if (dsu.merge(u[i], v[i])) {
			mst += w[i];
		}
	}

	std::vector<bool> f(1 << (2 * m), false);
	for (u32 s = 0u; s < (1u << m); s++) {
		if (__builtin_popcount(s) != n - 1) {
			continue;
		}

		std::vector<int> a;
		for (int i = 0; i < m; i++) {
			if (s >> i & 1u) {
				a.push_back(i);
			}
		}

		int sum = 0;
		for (int i : a) {
			sum += w[i];
		}
		if (sum != mst) {
			continue;
		}

		dsu.init(n);
		for (int i : a) {
			dsu.merge(u[i], v[i]);
		}
		if (dsu.size(0) != n) {
			continue;
		}

		for (u32 t = 0u; t < (1u << (n - 1)); t++) {
			std::vector<int> deg(n, 0);
			for (int i = 0; i < n - 1; i++) {
				deg[t >> i & 1u ? u[a[i]] : v[a[i]]]++;
			}

			if (std::count(deg.begin(), deg.end(), 0) == 1) {
				u32 mask = 0u;
				for (int i = 0; i < n - 1; i++) {
					mask |= 1u << (2 * a[i] + (t >> i & 1u));
				}
				f[mask] = true;
			}
		}
	}
	for (u32 s = 1u; s < (1u << (2 * m)); s++) {
		for (int i = 0; i < 2 * m && !f[s]; i++) {
			if (s >> i & 1u && f[s ^ (1u << i)]) {
				f[s] = true;
			}
		}
	}

	std::cout << (std::count(f.begin(), f.end(), true) / MInt(4).pow(m)).x << "\n";
}

int main() {
	freopen("years.in", "r", stdin);
	freopen("years.out", "w", stdout);

	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int c, t;
	std::cin >> c >> t;

	while (t--) {
		solve();
	}

	return 0;
}