#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
#include <set>
#include <string>
#include <cstring>
#include <queue>
#define rf freopen("in.in", "r", stdin)
#define wf freopen("out.out", "w", stdout)
#define rep(i, s, n) for(int i=int(s); i<=int(n); ++i)
using namespace std;
const int mx = 1e5 + 10, mod = 1e9+7;

int n, m, t;
map< pair< int, int>, int > edge;
vector<int> faulty_nodes;
int mark_faulty[mx], dp[1<<15][15][15];

int fact[mx], inv_fact[mx];
void pre_process()
{
	fact[0] = fact[1] = 1;
	for(int i = 2; i<mx; ++i)
		fact[i] = (1ll*fact[i-1]*i)%mod;

	inv_fact[mx-1] = 549915853;
	for(int i = mx-2; i>=0; --i)
		inv_fact[i] = (1ll*inv_fact[i+1]*(i+1))%mod;
}

int nCr(int n, int r)
{
	if(n < r)
		return 0;
	
	int ret = fact[n];
	ret = (1ll*ret*inv_fact[r])%mod;
	ret = (1ll*ret*inv_fact[n-r])%mod;
	return ret;
}

int main()
{
	//rf;// wf;
	ios::sync_with_stdio(0);

	pre_process();
	
	cin >> t;
	while(t--)
	{
		edge.clear(); faulty_nodes.clear();
		memset(mark_faulty, 0, sizeof mark_faulty);
		memset(dp, 0, sizeof dp);
		
		cin >> n >> m;
		for(int i = 1; i<=m; ++i)
		{
			int u, v;
			cin >> u >> v;

			if(!mark_faulty[u])
			{
				faulty_nodes.push_back(u);
				mark_faulty[u] = 1;
			}
		
			if(!mark_faulty[v])
			{
				faulty_nodes.push_back(v);
				mark_faulty[v] = 1;
			}

			edge[make_pair(u, v)] = 1;
			edge[make_pair(v, u)] = 1;
		}

		int normal_nodes = n - faulty_nodes.size();
		int ans = 0;

		for(int i = 0; i < faulty_nodes.size(); ++i)
			dp[1 << i][i][0] = 1;
		
		for(int mask = 1; mask < (1 << faulty_nodes.size()); ++mask)
		{
			for(int first_node = 0; first_node < faulty_nodes.size(); ++first_node)
			{
				for(int number_tied = 0; number_tied < faulty_nodes.size(); ++number_tied)
				{
					if(dp[mask][first_node][number_tied] > 0)
					{
						for(int new_first = 0; new_first < faulty_nodes.size(); ++new_first)
						{
							if((mask & (1 << new_first)) == 0)
							{
								int new_mask = mask ^ (1 << new_first);
								int edge_exists = edge[make_pair(faulty_nodes[new_first], faulty_nodes[first_node])];
								dp[new_mask][new_first][number_tied + edge_exists] = (dp[new_mask][new_first][number_tied + edge_exists] + dp[mask][first_node][number_tied])%mod;
							}
						}
					}

					if(mask == (1 << faulty_nodes.size()) - 1)
					{
						int val = dp[mask][first_node][number_tied];
						int get = (1ll*val*nCr(n-number_tied, faulty_nodes.size()))%mod;
						get = (1ll*get*fact[normal_nodes])%mod;

						ans = (ans + get)%mod;
					}
				}
			}
		}

		if(m == 0)
			ans = fact[n];

		cout << ans << '\n';
	}
	return 0;
}