Problem:
Score : 800 points

Problem Statement

There are N squares arranged in a row.
The squares are numbered 1, 2, ..., N, from left to right.

Snuke is painting each square in red, green or blue.
According to his aesthetic sense, the following M conditions must all be satisfied.
The i-th condition is:

There are exactly x_i different colors among squares l_i, l_i + 1, ..., r_i.

In how many ways can the squares be painted to satisfy all the conditions?
Find the count modulo 10^9+7.

Constraints

1 ≤ N ≤ 300

1 ≤ M ≤ 300

1 ≤ l_i ≤ r_i ≤ N

1 ≤ x_i ≤ 3

Input

Input is given from Standard Input in the following format:

N M
l_1 r_1 x_1
l_2 r_2 x_2
:
l_M r_M x_M

Output

Print the number of ways to paint the squares to satisfy all the conditions, modulo 10^9+7.

Sample Input 1

3 1
1 3 3

Sample Output 1

6

The six ways are:

RGB

RBG

GRB

GBR

BRG

BGR

where R, G and B correspond to red, green and blue squares, respectively.

Sample Input 2

4 2
1 3 1
2 4 2

Sample Output 2

6

The six ways are:

RRRG

RRRB

GGGR

GGGB

BBBR

BBBG

Sample Input 3

1 3
1 1 1
1 1 2
1 1 3

Sample Output 3

0

There are zero ways.

Sample Input 4

8 10
2 6 2
5 5 1
3 5 2
4 7 3
4 4 1
2 3 1
7 7 1
1 5 2
1 7 3
3 4 2

Sample Output 4

108

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }

    #[allow(dead_code)]
    pub fn get2<T: FromStr, U: FromStr>() -> (T, U)
    where
        <T as FromStr>::Err: Debug,
        <U as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().parse().unwrap(),
        )
    }
}

const M: usize = 1000000007;
fn main() {
    let (n, m): (usize, usize) = util::get2();
    let mut r_lrx = vec![Vec::new(); n + 1];

    for _ in 0..m {
        let lrx: Vec<usize> = util::gets();
        r_lrx[lrx[1]].push(lrx);
    }

    let mut dp = vec![vec![vec![0; n + 2]; n + 2]; n + 2];
    dp[0][0][0] = 1;

    for i in 0..n + 1 {
        for k in 0..n + 1 {
            for j in 0..n + 1 {
                if dp[i][k][j] > 0 {
                    let r = max(max(i, k), j);
                    if r_lrx[r].iter().all(|lrx| {
                        vec![i, k, j]
                            .into_iter()
                            .map(|p| lrx[0] <= p && p <= lrx[1])
                            .map(|b| if b { 1 } else { 0 })
                            .sum::<usize>() == lrx[2]
                    })
                    {
                        let pat = dp[i][k][j];
                        dp[r + 1][k][j] = (dp[r + 1][k][j] + pat) % M;
                        dp[i][r + 1][j] = (dp[i][r + 1][j] + pat) % M;
                        dp[i][k][r + 1] = (dp[i][k][r + 1] + pat) % M;
                    } else {
                        dp[i][k][j] = 0;
                    }
                }
            }
        }
    }

    let mut sum = 0;
    for i in 0..n {
        for k in 0..n {
            sum = (sum + dp[n][i][k]) % M;
            sum = (sum + dp[i][n][k]) % M;
            sum = (sum + dp[k][i][n]) % M;
        }
    }

    println!("{}", sum);

}