using System;
using System.Collections.Generic;
using System.Linq;

namespace x
{
    class Program
    {
        class Cond
        {
            public readonly int a;
            public readonly int b;
            public readonly int diff;
            public readonly int score;

            public Cond(int[] nums)
            {
                this.a = nums[0] - 1;
                this.b = nums[1] - 1;
                this.diff = nums[2];
                this.score = nums[3];
            }

        }

        static void Main(string[] args)
        {
            (var len, var maxVal, var condCount) = IOUtils.Read3Ints();
            var conds = Enumerable.Repeat(0, condCount)
                                .Select(_ => IOUtils.ReadInts())
                                .Select(ns => new Cond(ns))
                                .ToArray();

            var candidates = enumerateCandidates(len, maxVal).ToArray();

            var result = candidates.Select(c => calcScore(conds, c)).Max();
            System.Console.WriteLine(result);
        }

        private static long calcScore(Cond[] conds, IReadOnlyList<int> candidate)
        {
            var score = 0L;
            foreach (var cond in conds)
            {
                if (candidate[cond.b] - candidate[cond.a] == cond.diff)
                {
                    score += cond.score;
                }
            }
            return score;
        }

        static IEnumerable<IReadOnlyList<int>> enumerateCandidates(int len, int max)
        {
            var nums = Enumerable.Range(1, max).ToArray();

            var combis = MathUtils.EnumCombination(nums, len, true);

            foreach (var combi in combis)
            {
                yield return combi;
            }
        }
    }


    static class MathUtils
    {
        /// <summary>
        /// 組み合わせの数を返す
        /// </summary>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public static long C(long n, long k)
        {
            if (n < k) return 0;
            if (n == k) return 1;

            long x = 1;
            for (long i = 0; i < k; i++)
            {
                x = x * (n - i) / (i + 1);
            }
            return x;
        }

        /// <summary>
        /// 順列を列挙（幅優先）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="src"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public static IEnumerable<T[]> EnumPermutations<T>(IReadOnlyList<T> src, int k)
        {
            if (src.Count < k || k <= 0) throw new ArgumentOutOfRangeException(nameof(k));

            var queue = new Queue<List<int>>(Enumerable.Range(0, src.Count).Select(i => new List<int>() { i }));
            while (queue.Any())
            {
                var indexes = queue.Dequeue();

                if (indexes.Count == k)
                {
                    yield return indexes.Select(i => src[i]).ToArray();
                    continue;
                }

                for (int index = 0; index < src.Count; index++)
                {
                    if (indexes.Contains(index))
                    {
                        continue;
                    }

                    var newIndexes = new List<int>(indexes);
                    newIndexes.Add(index);
                    queue.Enqueue(newIndexes);
                }
            }
        }

        /// <summary>
        /// 組み合わせを列挙
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="src"></param>
        /// <param name="k"></param>
        /// <param name="allowsRepetition"></param>
        /// <returns></returns>
        public static IEnumerable<T[]> EnumCombination<T>(IReadOnlyList<T> src, int k, bool allowsRepetition)
        {
            if (k == 1)
            {
                foreach (var item in src)
                {
                    yield return new T[] { item };
                }
                yield break;
            }
            foreach (var item in src)
            {
                var leftside = new T[] { item };

                var unused = src.SkipWhile(e => !e.Equals(item)).Skip(allowsRepetition ? 0 : 1).ToList();

                foreach (var rightside in EnumCombination(unused, k - 1, allowsRepetition))
                {
                    yield return leftside.Concat(rightside).ToArray();
                }
            }
        }
    }
    
    static class IOUtils
    {
        public static (int a, int b) Read2Ints()
        {
            var vals = ReadInts();
            return (vals[0], vals[1]);
        }
        public static (int a, int b, int c) Read3Ints()
        {
            var vals = ReadInts();
            return (vals[0], vals[1], vals[2]);
        }
        public static IEnumerable<int[]> ReadIntLines(int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return ReadInts();
            }
        }
        public static IEnumerable<long[]> ReadLongLines(int count)
        {
            for (int i = 0; i < count; i++)
            {
                yield return ReadLongs();
            }
        }
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        public static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        public static ulong ReadUlong()
        {
            return ulong.Parse(Console.ReadLine());
        }
        public static int[] ReadInts()
        {
            return Console.ReadLine().Split(' ').Select(v => int.Parse(v)).ToArray();
        }
        public static long[] ReadLongs()
        {
            return Console.ReadLine().Split(' ').Select(v => long.Parse(v)).ToArray();
        }

        public static void WriteNums(params int[] nums)
        {
            Console.WriteLine(string.Join(" ", nums));
        }
    }
}


Measured memory_bytes: 48472