#include "bits/stdc++.h"
using namespace std;

typedef long long ll;
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)

int dy[] = { 0, 0, 1, -1 };
int dx[] = { 1, -1, 0, 0 };

ll A, B, C, D, E, F, G, H, I, J, K, L, M,
N, O, P, Q, R, S, T, U, V, W, X, Y, Z;

//* ?????????n??????????????\??????????????????????????????????????????
template <typename T>
vector<T> INP(ll n)
{
	vector<T> x;
	REP(i, n) {
		T tmp; cin >> tmp;
		x.push_back(tmp);
	}
	return x;
}
//* n??????1????????????????????\?????????????????????????????¨??????????????????
vector<char> SPRIT_STRING(ll n)
{
	string str; cin >> str;
	vector<char> cs(n);
	REP(i, n) cs[i] = str[i];
	return cs;
}
//* ??§?¨?nx, ny???Width,Height?????????????????????????????????????????§??????
inline bool rangeCheck2D(int nx, int ny, int Width, int Height)
{
	return nx >= 0 and nx < Width and ny >= 0 and ny < Height;
}
//* ?´???°?????? is_prime<unsigned>(N)
template<typename T, std::enable_if_t<std::is_unsigned<T>::value, std::nullptr_t> = nullptr>
bool is_prime(const T n) {
	if (n < 4) return n == 2 || n == 3;
	if (n % 2 == 0 || n % 3 == 0 || (n % 6 != 1 && n % 6 != 5)) return false;
	for (T i = 5; i * i <= n; i += 6) if (n % i == 0 || n % (i + 2) == 0) return false;
	return true;
}

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2007
namespace makePurseLight {
	void makePurseLight()
	{
		cin >> N;
		int n[] = { 500, 100, 50, 10 };
		while (true) {
			int num[4];
			REP(i, 4) cin >> num[3-i];
			int sum = 0;
			REP(i, 4) sum += n[i] * num[i];
			int ret = sum - N;
			vector<int> cnt(4);
			while (ret > 0) {
				REP(i, 4) if (ret >= n[i]) {
					ret -= n[i]; cnt[i]++;
					break;
				}
			}
			REP(i, 4) {
				int ri = 3 - i;
				int ans = num[ri] - cnt[ri];
				if (ans > 0) cout << n[ri] << " " << ans << endl;
			}
			cin >> N;
			if (N == 0)
				break;
			else
				cout << endl;
		}
	}
}

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0168
// DP??\???
namespace kannondou {
	void kannondou()
	{
		cin >> N;
		while (N) {
			ll dp[30];
			dp[0] = 1; dp[1] = 2; dp[2] = 4;
			FOR(i, 3, N)
				dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
			ll day = dp[N - 1] / 10 + ((dp[N - 1] % 10 == 0) ? 0 : 1);
			ll year = day / 365 + ((day % 365) ? 0 : 1);
			cout << year + 1 << endl;
			cin >> N;
		}
	}
}

namespace heianKyoWalking {
	void heianKyoWalking()
	{
		cin >> K;
		int dx2[] = { 0, 1 };
		int dy2[] = { 1, 0 };
		while (K--) {
			int gx, gy; cin >> gx >> gy;
			cin >> N;
			typedef pair<int, int> iPnt2d;
			vector<pair<iPnt2d, iPnt2d>> ms(N);
			REP(i, N) {
				int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
				ms[i].first.first = x1; ms[i].first.second = y1;
				ms[i].second.first = x2; ms[i].second.second = y2;
			}
			++gx; ++gy;
			int dp[16][16];
			dp[0][0] = 0;
			FOR(i, 1, gx) {
				if (i > 1 and dp[i - 1][0] == 0) dp[i][0] = 0;
				else dp[i][0] = 1;
				REP(j, ms.size()) {
					auto m = ms[j];
					if ((m.first == iPnt2d(i, 0) and m.second == iPnt2d(i - 1, 0)) or
						(m.first == iPnt2d(i - 1, 0) and m.second == iPnt2d(i, 0))) {
						dp[i][0] = 0;
						break;
					}
				}
			}
			FOR(i, 1, gy) {
				if (i > 1 and dp[0][i - 1] == 0) dp[0][i] = 0;
				else dp[0][i] = 1;
				REP(j, ms.size()) {
					auto m = ms[j];
					if ((m.first == iPnt2d(0, i) and m.second == iPnt2d(0, i - 1)) or
						(m.first == iPnt2d(0, i - 1) and m.second == iPnt2d(0, i))) {
						dp[0][i] = 0;
						break;
					}
				}
			}
			
			FOR(i, 1, gx) {
				FOR(j, 1, gy) {
					int dcost = dp[i][j - 1];
					int lcost = dp[i - 1][j];
					iPnt2d current(i, j), left(i - 1, j), down(i, j - 1);
					REP(k, ms.size()) {
						auto m = ms[k];
						if ((m.first == current and m.second == down) or
							(m.first == down and m.second == current))
							dcost = 0;
						if ((m.first == current and m.second == left) or
							(m.first == left and m.second == current))
							lcost = 0;
					}
					dp[i][j] = dcost + lcost;
				}
			}
			int ans = dp[gx-1][gy-1];
			if (ans == 0)
				cout << "Miserable Hokusai!" << endl;
			else
				cout << ans << endl;
		}
	}
}

// CodeForces
namespace foxAndCardGame {
	void foxAndCardGame()
	{
		cin >> N;
		int nums[105][105];
		int in[105];
		REP(i, N) {
			int c; cin >> c;
			in[i] = c;
			REP(j, c) {
				cin >> nums[i][j];
			}
		}
		int cielA = 0, jiroA = 0;
		vector<int> odds;
		REP(i, N) {
			int n = in[i];
			REP(j, n / 2) cielA += nums[i][j];
			if (n % 2 == 0) {
				if (n > 1) FOR(j, n / 2, n) jiroA += nums[i][j];
			}
			else {
				if (n > 2) FOR(j, n / 2 + 1, n) jiroA += nums[i][j];
				odds.push_back(nums[i][n / 2]);
			}
		}
		sort(odds.rbegin(), odds.rend());
		REP(i, odds.size()) {
			if (i % 2 == 0)
				cielA += odds[i];
			else
				jiroA += odds[i];
		}
		cout << cielA << " " << jiroA << endl;
	}
}

int main()
{
	heianKyoWalking::heianKyoWalking();
	return 0;
}


Measured memory_bytes: 3084