#include <cstdio>
#include <cstring>
#include <cassert>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
 
#define FOR(i,a) for (__typeof((a).begin()) i = (a).begin(); i != (a).end(); ++ i)
 
int MOD = 1000000000 + 7;
 
struct Node
{
	long long layer;
	int num;
	
	Node(long long layer, int num) : layer(layer), num(num) {
	}
	
	long long toID(int m) {
		return layer * m + num;
	}
};
 
bool byLayer(const Node &a, const Node &b)
{
	return a.layer < b.layer || a.layer == b.layer && a.num < b.num;
}
 
bool operator == (const Node &a, const Node &b)
{
	return a.layer == b.layer && a.num == b.num;
}
 
int powmod(int a, long long b)
{
	if (b == 0) {
		return 1;
	}
	int ret = powmod(a, b >> 1);
	ret = (long long)ret * ret % MOD;
	if (b & 1) {
		ret = (long long)ret * a % MOD;
	}
	return ret;
}
 
int main()
{
	long long layers;
	int m, k;
	assert(scanf("%lld%d%d", &layers, &m, &k) == 3);
	assert(1 <= layers && layers <= 1000000000000LL);
	assert(1 <= m && m <= 100000);
	assert(1 <= k && k <= 50000);
	map<long long, vector<long long> > edges;
	vector<Node> special;
	for (int i = 0; i < k; ++ i) {
		long long layer1, layer2;
		int num1, num2;
		assert(scanf("%lld%d%lld%d", &layer1, &num1, &layer2, &num2) == 4);
		assert(0 <= layer1 && layer1 < layer2 && layer2 < layers + 2);
		assert(0 <= num1 && num1 < m);
		assert(0 <= num2 && num2 < m);
		if (layer1 == 0 || layer1 == layers + 1) {
			assert(num1 == 0);
		}
		if (layer2 == 0 || layer2 == layers + 1) {
			assert(num2 == 0);
		}
		edges[layer2 * m + num2].push_back(layer1 * m + num1);
		
		special.push_back(Node(layer1, num1));
		special.push_back(Node(layer2, num2));
	}
	
	sort(special.begin(), special.end(), byLayer);
	special.erase(unique(special.begin(), special.end()), special.end());
	
	map<long long, int> memo;
	long long lastLayer = 0;
	int lastSum = 1;
	for (int i = 0; i < special.size(); ++ i) {
		int j = i;
		while (j < special.size() && special[j].layer == special[i].layer) {
			++ j;
		}
		long long currentLayer = special[i].layer;
		
		if (currentLayer - 1 > lastLayer) {
			lastSum = (long long)lastSum * powmod(m, currentLayer - 1 - lastLayer) % MOD;
			lastLayer = currentLayer - 1;
		}
		
		int currentSum = lastSum;
		if (lastLayer < currentLayer && currentLayer < layers + 1) {
			currentSum = (long long)currentSum * m % MOD;
		}
		
		for (int iter = i; iter < j; ++ iter) {
			long long to = special[iter].toID(m);
			int sum = lastSum;
			FOR (node, edges[to]) {
				long long from = *node;
				int delta = memo[from];
				sum = (sum + delta) % MOD;
				currentSum = (currentSum + delta) % MOD;
			}
			memo[to] = sum;
		}
		
		lastLayer = currentLayer;
		lastSum = currentSum;
		
		i = j - 1;
	}
	
	if (lastLayer < layers) {
		lastSum = (long long)lastSum * powmod(m, layers - lastLayer) % MOD;
	}
	
	printf("%d\n", lastSum);
	
	return 0;
}