#include <bits/stdc++.h>
using namespace std;
struct Edge {
  int64_t v, f, c;
  Edge(int64_t v, int64_t f, int64_t c) : v(v), f(f), c(c) {}
  int64_t get_capacity() { return c - f; }
};
const int64_t INF = (int64_t)(1e9) + 666;
const int64_t N = 10000;
const int64_t S = N - 2;
const int64_t T = N - 1;
vector<Edge> edges;
vector<int64_t> g[N];
int64_t dist[N];
int64_t ptr[N];
void add_edge(int64_t v, int64_t u, int64_t c) {
  g[v].emplace_back(edges.size());
  edges.emplace_back(u, 0, c);
  g[u].emplace_back(edges.size());
  edges.emplace_back(v, 0, 0);
}
bool bfs() {
  fill(dist, dist + N, INF);
  dist[S] = 0;
  queue<int64_t> q;
  q.push(S);
  while (!q.empty()) {
    int64_t v = q.front();
    q.pop();
    for (int64_t id : g[v]) {
      if (edges[id].get_capacity() < 1) {
        continue;
      }
      if (dist[edges[id].v] > dist[v] + 1) {
        dist[edges[id].v] = dist[v] + 1;
        q.push(edges[id].v);
      }
    }
  }
  return dist[T] != INF;
}
int64_t dfs(int64_t v, int64_t min_c) {
  if (v == T) {
    return min_c;
  }
  while (ptr[v] < g[v].size()) {
    int64_t id = g[v][ptr[v]];
    ++ptr[v];
    if (edges[id].get_capacity() < 1) {
      continue;
    }
    if (dist[edges[id].v] != dist[v] + 1) {
      continue;
    }
    int64_t x = dfs(edges[id].v, min(min_c, edges[id].get_capacity()));
    if (x) {
      --ptr[v];
      edges[id].f += x;
      edges[id ^ 1].f -= x;
      return x;
    }
  }
  return 0;
}
int main() {
  int64_t n, h, m;
  cin >> n >> h >> m;
  int64_t sum = 0;
  for (int64_t i = 0; i < n; ++i) {
    for (int64_t j = 0; j < h; ++j) {
      sum += 2 * (j + 1) - 1;
      add_edge(S, i * h + j, 2 * (j + 1) - 1);
    }
  }
  for (int64_t q = 0; q < m; ++q) {
    int64_t left, right, x, c;
    cin >> left >> right >> x >> c;
    add_edge(q + N / 2, T, c);
    for (int64_t i = left - 1; i < right; ++i) {
      for (int64_t j = x; j < h; ++j) {
        add_edge(i * h + j, q + N / 2, INF);
      }
    }
  }
  while (bfs()) {
    fill(ptr, ptr + N, 0);
    while (dfs(S, INF)) {
    }
  }
  for (int64_t id : g[S]) {
    sum -= edges[id].f;
  }
  cout << sum << endl;
  return 0;
}
