#include <cstdlib>
#include <map>
#include <array>
#include <algorithm>
#include <functional>
#include <vector>
#include <iterator>
#include <cstdio>
#include <utility>


struct Range
{   
    struct It {   int num, step; int operator*(){return num;} void operator++(){num += step;} bool operator!=(const It& other){return num != other.num;} };
    Range(int ee):b(0),e(ee){}
    Range(int bb, int ee):b(bb), e(ee){}
    It begin(){return {b, (b < e? 1: -1)};}
    It end(){return {e, 0};}
    int b, e;
};

template<typename T> inline T& UMAX(T& x, T y){if(x < y)x = y; return x;}
template<typename T> inline T& UMIN(T& x, T y){if(y < x)x = y; return x;}
template<typename T, typename... Args> struct ArithmiticPromotion { typedef decltype(T() + typename ArithmiticPromotion<Args...>::type()) type; };
template<typename T, typename U> struct ArithmiticPromotion<T, U> { typedef decltype(T() + U()) type; };
template<typename T> struct ArithmiticPromotion<T, T> { typedef T type; };
template<typename T> struct ArithmiticPromotion<T> { typedef T type; };
template<typename T, typename U> typename ArithmiticPromotion<T, U>::type MAX(T a, U b) { return a < b? b: a; }
template<typename T, typename... Args> typename ArithmiticPromotion<T, Args...>::type MAX(T a, Args... args) { return MAX(a, MAX(args...)); }
template<typename T, typename U> typename ArithmiticPromotion<T, U>::type MIN(T a, U b) { return a < b? a: b; }
template<typename T, typename... Args> typename ArithmiticPromotion<T, Args...>::type MIN(T a, Args... args) { return MIN(a, MIN(args...)); }



template<typename T> struct ScanfSpecifier{};
#define DEF(T,V) template<> struct ScanfSpecifier<T>{static constexpr const char* value = V;};
DEF(char*,"%s")DEF(int,"%d")DEF(double,"%lf")DEF(float,"%f")DEF(char,"%c")DEF(const char*,"%s")DEF(unsigned long,"%lu")DEF(unsigned int, "%u")
#ifdef _MSC_VER
DEF(long long int,"%I64d")
#else
DEF(long long int,"%lld")
#endif
#undef DEF
template<typename T> int RD(T& arg){return std::scanf(ScanfSpecifier<T>::value, &arg);}
template<int S> int RD(char (&arg)[S]){return std::scanf("%s", arg);}
int RD(char* arg){return std::scanf("%s", arg);}
template<> int RD<char>(char& arg){return std::scanf(" %c", &arg);}
template<typename T, typename... Args> int RD(T& arg1, Args&... args) {return RD(arg1) + RD(args...);}
template<typename T> T RD(){T ret; RD(ret); return ret;}
template<typename It> void RDV(It begin, It end) { while(begin != end) RD(*begin++); }
template<typename C> void RDV(C& c) {RDV(std::begin(c), std::end(c));}
template<typename T> void WT(T arg) {std::printf(ScanfSpecifier<T>::value, arg); }
template<typename T, typename U> void WT(std::pair<T, U> arg) {std::printf("("); WT(arg.first); std::printf(", "); WT(arg.second); std::printf(")");}
template<typename... Args> void WT(Args... args) { int alc = 0; int dummy[] = {((alc++? std::printf(" "): 0), WT(args), 0)...}; }

template<typename... Args> void WTL(Args... args) { WT(args...); std::printf("\n"); }
template<typename It> void WTV(It begin, It end) { int alc = 0; while(begin != end) (alc++? std::printf(" "): 0), WT(*begin++); }
template<typename C> void WTV(const C& c) {WTV(std::begin(c), std::end(c));}
template<typename It> void WTVL(It begin, It end) { WTV(begin, end); std::printf("\n"); }
template<typename C> void WTVL(const C& c) {WTVL(std::begin(c), std::end(c));}

#define _M_VARGS_NUM_IMPL(_1, _2, _3, _4, _5, _6, N, ...) N
#define _M_VARGS_NUM(...) _M_VARGS_NUM_IMPL(__VA_ARGS__, 6, 5, 4, 3, 2, 1)
#define _W1(_1) (#_1[0] == '"' || #_1[0] == '\''? WT("", _1, ""): WT('[', #_1, '=', _1, ']'))
#define _W2(_1, _2) (_W1(_1), _W1(_2))
#define _W3(_1, _2, _3) (_W1(_1), _W2(_2, _3))
#define _W4(_1, _2, _3, _4) (_W1(_1), _W3(_2, _3, _4))
#define _W5(_1, _2, _3, _4, _5) (_W1(_1), _W4(_2, _3, _4, _5))
#define _WW_IMPL2(num, ...) _W ## num(__VA_ARGS__)
#define _WW_IMPL(num, ...) _WW_IMPL2(num, __VA_ARGS__)
#define WW(...) (std::printf("(%03d) ", __LINE__), _WW_IMPL(_M_VARGS_NUM(__VA_ARGS__), __VA_ARGS__), WTL(""))



template<unsigned int Z>
struct ZpZ
{
    static const unsigned int P = Z;
    using U64 = unsigned long long int;
    U64 value;
    ZpZ(long long int n) {if(std::abs(n) >= P)n %= P; if(n < 0)n += P; value = n;}
    ZpZ():value(0){}
    ZpZ& operator+=(ZpZ p){if((value += p.value) >= P)value -= P; return *this;}
    ZpZ& operator-=(ZpZ p){if(value >= p.value)value -= p.value; else value += P - p.value; return *this;}
    ZpZ& operator*=(ZpZ p){value = value * p.value % P; return *this;}
    ZpZ& operator/=(ZpZ p){value = value * p.inverse().value % P; return *this;}
    bool operator==(ZpZ p){return value == p.value;}
    bool operator!=(ZpZ p){return value != p.value;}

#define DEF(op) ZpZ operator op(ZpZ r)const{return ZpZ(value) op##= r;}
DEF(+)DEF(-)DEF(*)DEF(/)
#undef DEF

    explicit operator long long int()const{return value;}
    explicit operator int()const{return value;}
    ZpZ operator-(){return P - value;}
    ZpZ inverse()
    {
        int a = value, b = P, u = 1, v = 0;
        while(b) 
        {
            int t = a / b;
            std::swap(a -= t * b, b); 
            std::swap(u -= t * v, v);
        }
        if(u < 0) u += P;
        return u;
    }
    ZpZ pow(U64 e)
    {
        U64 ret = 1, base = value;
        while(e)
        {
            if((e & 1) && ((ret *= base) >> 32))
                ret %= P;
            if((base *= base) >> 32)
                base %= P;
            e >>= 1;
        }
        return ret;
    }

};

template<unsigned int P>
void WT(ZpZ<P> arg) {WT((int)arg);}






//alias
//RD[L],RDV[L],WT[L],WTV[L] for i/o
using RG = Range;
//template
#include <vector>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <cstdlib>
#include <algorithm>
#include <functional>
using namespace std;

//alias
//RD[L],RDV[L],WT[L],WTV[L] for i/o
const int MOD = 1e9 + 7;
using ZZ = ZpZ<MOD>;
ZZ min(ZZ a, ZZ b){return std::min(a.value, b.value);}
ZZ max(ZZ a, ZZ b){return std::max(a.value, b.value);}
typedef long long int ll;
int N, M;

vector<pair<int, int>> cond[567];


int dp[309][309][309];

int f(int pos, int p1, int p2)
{
    if(pos == N + 1)
        return 1;

    int& ret = dp[pos][p1][p2];
    if(ret)
        return ret - 1;

    ZZ alc = 0;

    auto g = [&](int pos, int p2, int p3)
    {
        bool check = true;
        for(auto p: cond[pos])
            if((p2 >= p.first) + (p3 >= p.first) != p.second - 1)
                check = false;
        if(check)
                alc += f(pos + 1, p2, p3);
    };

    g(pos, p1, p2);
    g(pos, pos - 1, p2);
    g(pos, pos - 1, p1);


    ret = (int)alc;

    return ret++;

}

int main()
{
    RD(N, M);
    while(M--)
    {
        int l, r, x;
        RD(l, r, x);

        cond[r].push_back({l, x});
    }


    WTL(f(1, 0, 0));

}






Measured memory_bytes: 110976