package main

import (
	"io"
	"os"
	"strconv"
)

type Event struct {
	p    int
	d    int64
	next int
}

type Fenwick struct {
	n    int
	bit  int
	cnt  []int64
	cost []int64
}

func NewFenwick(n int) *Fenwick {
	b := 1
	for b<<1 <= n {
		b <<= 1
	}
	return &Fenwick{
		n:    n,
		bit:  b,
		cnt:  make([]int64, n+1),
		cost: make([]int64, n+1),
	}
}

func (f *Fenwick) Add(i int, delta int64) {
	dc := delta * int64(i)
	for i <= f.n {
		f.cnt[i] += delta
		f.cost[i] += dc
		i += i & -i
	}
}

func (f *Fenwick) CheapestCost(k int64) int64 {
	idx := 0
	var cntAcc, costAcc int64
	for step := f.bit; step > 0; step >>= 1 {
		next := idx + step
		if next <= f.n && cntAcc+f.cnt[next] < k {
			idx = next
			cntAcc += f.cnt[next]
			costAcc += f.cost[next]
		}
	}
	return costAcc + (k-cntAcc)*int64(idx+1)
}

type FastScanner struct {
	data []byte
	pos  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.pos < fs.n {
		b := fs.data[fs.pos]
		if b >= '0' && b <= '9' {
			break
		}
		fs.pos++
	}
	val := 0
	for fs.pos < fs.n {
		b := fs.data[fs.pos]
		if b < '0' || b > '9' {
			break
		}
		val = val*10 + int(b-'0')
		fs.pos++
	}
	return val
}

func main() {
	in := NewFastScanner()
	n := in.NextInt()
	k := int64(in.NextInt())
	m := in.NextInt()

	head := make([]int, n+2)
	for i := range head {
		head[i] = -1
	}
	events := make([]Event, 0, 2*m)

	addEvent := func(day, p int, d int64) {
		events = append(events, Event{p: p, d: d, next: head[day]})
		head[day] = len(events) - 1
	}

	for i := 0; i < m; i++ {
		l := in.NextInt()
		r := in.NextInt()
		c := int64(in.NextInt())
		p := in.NextInt()
		addEvent(l, p, c)
		if r+1 <= n {
			addEvent(r+1, p, -c)
		}
	}

	const maxPrice = 1000000
	fw := NewFenwick(maxPrice)

	var totalCnt, totalCost, ans int64

	for day := 1; day <= n; day++ {
		for e := head[day]; e != -1; e = events[e].next {
			p := events[e].p
			d := events[e].d
			fw.Add(p, d)
			totalCnt += d
			totalCost += d * int64(p)
		}
		if totalCnt <= k {
			ans += totalCost
		} else {
			ans += fw.CheapestCost(k)
		}
	}

	os.Stdout.WriteString(strconv.FormatInt(ans, 10))
}