Problem:
Score : 300 points

Problem Statement

Given are positive integers N, M, Q, and Q quadruples of integers ( a_i , b_i , c_i , d_i ).

Consider a sequence A satisfying the following conditions:

A is a sequence of N positive integers.

1 \leq A_1 \leq A_2 \le \cdots \leq A_N \leq M.

Let us define a score of this sequence as follows:

The score is the sum of d_i over all indices i such that A_{b_i} - A_{a_i} = c_i. (If there is no such i, the score is 0.)

Find the maximum possible score of A.

Constraints

All values in input are integers.

2 ≤ N ≤ 10

1 \leq M \leq 10

1 \leq Q \leq 50

1 \leq a_i < b_i \leq N ( i = 1, 2, ..., Q )

0 \leq c_i \leq M - 1 ( i = 1, 2, ..., Q )

(a_i, b_i, c_i) \neq (a_j, b_j, c_j) (where i \neq j)

1 \leq d_i \leq 10^5 ( i = 1, 2, ..., Q )

Input

Input is given from Standard Input in the following format:

N M Q
a_1 b_1 c_1 d_1
:
a_Q b_Q c_Q d_Q

Output

Print the maximum possible score of A.

Sample Input 1

3 4 3
1 3 3 100
1 2 2 10
2 3 2 10

Sample Output 1

110

When A = \{1, 3, 4\}, its score is 110. Under these conditions, no sequence has a score greater than 110, so the answer is 110.

Sample Input 2

4 6 10
2 4 1 86568
1 4 0 90629
2 3 0 90310
3 4 1 29211
3 4 3 78537
3 4 2 8580
1 2 1 96263
1 4 2 2156
1 2 0 94325
1 4 3 94328

Sample Output 2

357500

Sample Input 3

10 10 1
1 10 9 1

Sample Output 3

1

Solution in Kotlin (1.3.71) (judge verdict: Accepted)

import kotlin.math.*
import java.util.*

data class Quartet<out A, out B, out C, out D>(val first: A, val second: B, val third: C, val fourth: D)

fun main(args: Array<String>) {
  val (_, m, q) = readLine()!!.split(' ').map(String::toInt)
  val rules = Array(q) {
    val (a, b, c, d) = readLine()!!.split(' ').map(String::toInt)
    Quartet(a - 1, b - 1, c, d)
  }
  var ans = 0
  for (a0 in 1..m)
    for (a1 in a0..m)
      for (a2 in a1..m)
        for (a3 in a2..m)
          for (a4 in a3..m)
            for (a5 in a4..m)
              for (a6 in a5..m)
                for (a7 in a6..m)
                  for (a8 in a7..m)
                    for (a9 in a8..m) {
                      val a = intArrayOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
                      var sc = 0
                      for (r in rules) {
                        if (a[r.second] - a[r.first] == r.third) {
                          sc += r.fourth
                        }
                      }
                      ans = max(ans, sc)
                    }
  println(ans)
}