#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
#define rep(i,a,n) for(int i=(a);i<=(n);++i)
#define per(i,a,n) for(int i=(n);i>=(a);--i)
#define SZ(x) ((int)(x).size())

using namespace std;
typedef double db;
typedef long long ll;
typedef pair<int,int> pii;

const int maxn=5e3+10,mod=1e9+7;

inline void rd(){};
template<typename T1,typename ...T2>
inline void rd(T1 &x,T2 &...rest){
    bool w=1; x=0; char ch=getchar();
    while(!isdigit(ch)){w^=(ch=='-');ch=getchar();}
    while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
    w?0:x=-x;
    rd(rest...);
}

template<int MOD> struct mint {
    static const int mod = MOD;
    int v; 
    explicit operator int() const { return v; }
    mint():v(0) {}
    mint(ll _v) { 
        v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
        if (v < 0) v += MOD; 
    }
    bool operator==(const mint& o) const {return v==o.v;}
    friend bool operator!=(const mint& a, const mint& b) {return !(a==b);}
    friend bool operator<(const mint& a, const mint& b) {return a.v<b.v;}
    mint& operator+=(const mint& o){ 
        if ((v += o.v) >= MOD) v -= MOD; 
        return *this; 
    }
    mint& operator-=(const mint& o){ 
        if ((v -= o.v) < 0) v += MOD; 
        return *this; 
    }
    mint& operator*=(const mint& o){ v=int((ll)v*o.v%MOD); return *this;}
    mint& operator/=(const mint& o) { return (*this) *= _inv(o); }
    friend mint pow(mint a, ll p) {
        mint ans = 1; 
        assert(p >= 0);
        for (; p; p /= 2, a *= a) if (p&1) ans *= a;
        return ans; 
    }
    friend mint _inv(const mint& a) { 
        assert(a.v != 0); 
        return pow(a,MOD-2);
    }
    mint operator-() const { return mint(-v); }
    mint& operator++() { return *this += 1; }
    mint& operator--() { return *this -= 1; }
    friend mint operator+(mint a, const mint& b) { return a += b; }
    friend mint operator-(mint a, const mint& b) { return a -= b; }
    friend mint operator*(mint a, const mint& b) { return a *= b; }
    friend mint operator/(mint a, const mint& b) { return a /= b; }
};
using mi = mint<mod>;

int n,m;
vector<pii> event[maxn],h[maxn],w[maxn];
vector<int> val;
mi s[maxn],t[maxn];

inline void add(int x,int y,mi v){
	if(v==0) return;
	int nw=SZ(val);
	val.push_back((int)v);
	h[x].push_back({y,nw});
	w[y].push_back({x,nw});
	s[x]+=v; s[y]+=v;
}

inline void init(){
	rep(i,0,n){
		event[i].clear();
		h[i].clear();
		w[i].clear();
		s[i]=0;
	}
	val.clear();
}

inline void solve(){
	rd(n,m); 
	init();	
	rep(i,1,m){
		int l,r,x;
		rd(l,r,x);
		event[r].push_back({l,x});
	}
	add(0,0,1);
	rep(i,0,n){
		int jl=0,jr=n+1,kl=0,kr=n+1;
		for(auto [j,x]:event[i]){
			if(x==1) jr=min(jr,j-1);
			if(x==2) jl=max(jl,j),kr=min(kr,j-1);
			if(x==3) kl=max(kl,j);
		}
		rep(j,0,i){
			if(jl<=j && j<=jr) continue;
			for(auto [y,id]:h[j]){
				s[j]-=val[id]; s[y]-=val[id];
				val[id]=0;
			}
			h[j].clear();
		}
		rep(j,0,i){
			if(kl<=j && j<=kr) continue;
			for(auto [y,id]:w[j]){
				s[j]-=val[id]; s[y]-=val[id];
				val[id]=0;
			}
			w[j].clear();
		}
		if(i!=n){
			rep(j,0,i) t[j]=s[j];
			rep(j,0,i) add(i,j,t[j]);
		}
	}
	mi res=0;
	rep(i,0,n) res+=s[i];
	printf("%d\n",res/2);
}

signed main(){
    int _=1;
    scanf("%d",&_); 
    while(_--) solve();
}