/*

https://atcoder.jp/contests/arc074/tasks/arc074_c

ad-hocに解けるはず
数字が小さい区間に大きい区間が含まれていたら0
まず、1の区間は1色のみ(当たり前)
3の区間は全ての色

dpだとして、どんな状態がまとめれれる？
dp[i][B][G] = i番目まで見て,青がB個,緑がG個の場合の数
→複数ある条件の対処ができない

ではどうやって…？
R,G,Bの個数を管理?
区間の中にある数のΔをr,g,bで表す

1種類→ r*g + r*b + g*b = 0
2種類→ 上を満たさないかつ r*g*b = 0
3種類→ 上を満たさない

======少し答えを見た=====

一番右にある色のindexを管理する？
dp[r][g][b]
更新はr,g,bのどれかを変更する

条件に合わないのを切り捨てるには、
1 → r,g,bで2番目に大きいのがl-1以下を0にする
など分かるはず

更新にかかる計算回数は…？
一つはi-1なのがわかってる
更新の際見るべきは300*300*3
条件が存在しない時を考えよう
O(N^3)で行けるはず

条件による切り捨てを考える
M回切り捨てる、条件を見るのは最大のやつ以外の2つなので O(M * N**2)
結論として O(N^3+MN^2)で解ける

*/

#include <bits/stdc++.h>
#include <iostream>
#include <limits>
#include <numeric>
#include <type_traits>

using namespace std;

#define rep(i,n,m) for(int (i)=(n);(i)<(m);(i)++)
#define rrep(i,n,m) for(int (i)=(n);(i)>(m);(i)--)
using ll = long long;
const int mod = 1000000007;

int main(){

    int N,M;
    cin >> N >> M;

    vector<vector<vector<int>>> lx(N+1,vector<vector<int>> (0));
    int l,r,x;
    rep(i,0,M){
        cin >> l >> r >> x;
        lx[r].push_back({l,x});
    }

    vector<vector<vector<int>>> dp(N+1,vector<vector<int>> (N+1 , vector<int> (N+1,0)));
    dp[0][0][0] = 1;

    rep(i,1,N+1){

        rep(g,0,i){
            rep(b,0,i){
                dp[i][g][b] += dp[i-1][g][b];
                dp[i][g][b] %= mod;
                dp[i-1][i][b] += dp[i-1][g][b];
                dp[i-1][i][b] %= mod;
                dp[i-1][g][i] += dp[i-1][g][b];
                dp[i-1][g][i] %= mod;
            }
        }

        rep(r,0,i){
            rep(b,0,i){
                dp[i][i-1][b] += dp[r][i-1][b];
                dp[i][i-1][b] %= mod;
                dp[r][i][b] += dp[r][i-1][b];
                dp[r][i][b] %= mod;
                dp[r][i-1][i] += dp[r][i-1][b];
                dp[r][i-1][i] %= mod;
            }
        }

        rep(r,0,i){
            rep(g,0,i){
                dp[i][g][i-1] += dp[r][g][i-1];
                dp[i][g][i-1] %= mod;
                dp[r][i][i-1] += dp[r][g][i-1];
                dp[r][i][i-1] %= mod;
                dp[r][g][i] += dp[r][g][i-1];
                dp[r][g][i] %= mod;
            }
        }

        //remove
        rep(j,0,lx[i].size()){
            l = lx[i][j][0];
            x = lx[i][j][1];

            if (x==1){
                rep(g,0,i){
                    rep(b,0,i){
                        if (g >= l || b >= l) dp[i][g][b] = 0;
                    }
                }
                rep(r,0,i){
                    rep(b,0,i){
                        if (r >= l || b >= l) dp[r][i][b] = 0;
                    }
                }
                rep(r,0,i){
                    rep(g,0,i){
                        if (r >= l || g >= l) dp[r][g][i] = 0;
                    }
                }
            }else if (x==2){
                rep(g,0,i){
                    rep(b,0,i){
                        if (!((g >= l)&&(l > b) || (b >= l)&&(l > g))) dp[i][g][b] = 0;
                    }
                }
                rep(r,0,i){
                    rep(b,0,i){
                        if (!((r >= l)&&(l > b) || (b >= l)&&(l > r))) dp[r][i][b] = 0;
                    }
                }
                rep(r,0,i){
                    rep(g,0,i){
                        if (!((g >= l)&&(l > r) || (r >= l)&&(l > g))) dp[r][g][i] = 0;
                    }
                }
            }else{
                rep(g,0,i){
                    rep(b,0,i){
                        if (g < l || b < l) dp[i][g][b] = 0;
                    }
                }
                rep(r,0,i){
                    rep(b,0,i){
                        if (r < l || b < l) dp[r][i][b] = 0;
                    }
                }
                rep(r,0,i){
                    rep(g,0,i){
                        if (r < l || g < l) dp[r][g][i] = 0;
                    }
                }
            }


        }
    }

    int ans = 0;
    rep(i,0,N){
        rep(j,0,N){
            ans += dp[N][i][j];
            ans %= mod;
        }
    }

    cout << ans << endl;
}

Measured memory_bytes: 113336