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 Kotlin (1.0.0) (judge verdict: Memory Limit Exceeded)

import java.io.BufferedReader
import java.io.InputStreamReader

const val MOD = 1000000009L

fun main(omkar: Array<String>) {
    val jin = BufferedReader(InputStreamReader(System.`in`))
    val line = jin.readLine().split(" ")
    val n = line[0].toInt()
    val m = line[1].toInt()
    val earliest = Array(4) { IntArray(n + 1) { Int.MAX_VALUE } }
    val latest = Array(4) { IntArray(n + 1) }
    for (j in 1..m) {
        val line = jin.readLine().split(" ")
        val l = line[0].toInt()
        val r = line[1].toInt()
        val x = line[2].toInt()
        earliest[x][r] = Math.min(earliest[x][r], l)
        latest[x][r] = Math.max(latest[x][r], l)
    }
    val dp = Array(n + 1) { Array(n + 1) { LongArray(n + 1) } }
    dp[0][0][0] = 1L
    for (j1 in 0 until n) {
        for (j2 in 0 until n) {
            for (j3 in 0 until n) {
                if (earliest[1][j1] > j2 && latest[2][j1] <= j2 && earliest[2][j1] > j3 && latest[3][j1] <= j3) {
                    // same as j1
                    dp[j1 + 1][j2][j3] += dp[j1][j2][j3]
                    dp[j1 + 1][j2][j3] %= MOD
                    // same as j2
                    dp[j1 + 1][j1][j3] += dp[j1][j2][j3]
                    dp[j1 + 1][j1][j3] %= MOD
                    // same as j3
                    dp[j1 + 1][j1][j2] += dp[j1][j2][j3]
                    dp[j1 + 1][j1][j2] %= MOD
                }
            }
        }
    }
    var answer = 0L
    for (j2 in 0 until n) {
        for (j3 in 0 until n) {
            if (earliest[1][n] > j2 && latest[2][n] <= j2 && earliest[2][n] > j3 && latest[3][n] <= j3) {
                answer += dp[n][j2][j3]
                answer %= MOD
            }
        }
    }
    println(answer)
}