#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <utility>
#include <cstdlib>
#include <memory>
#include <queue>
#include <cassert>
#include <cmath>
#include <ctime>
#include <complex>
#include <bitset>
#include <fstream>
#include <unordered_map>
#include <unordered_set>
#include <numeric>

using namespace std;

#define ws ws_____________________
#define y1 y1_____________________
#define y0 y0_____________________
#define left left_________________
#define right right_______________
#define next next_________________
#define prev prev_________________
#define hash hash_________________

#define pb push_back
#define fst first
#define snd second
#define mp make_pair 
#define sz(C) ((int) (C).size())
#define forn(i, n) for (int i = 0; i < (int) n; ++i)
#define ford(i, n) for (int i = ((int) n) - 1; i >= 0; --i)
#define all(C) begin(C), end(C)

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef vector<vector <int> > vvi;
typedef vector<pii> vii;
typedef long double ld;
typedef complex<double> cd;
typedef vector<cd> vcd;

#define FILE_NAME "a"

const int MAXN = 4e5 + 10;
const ll INF = 2e9 + 10;

struct pnt {
	int r, c;
	int val;

	void read() {
		scanf("%d%d%d", &r, &c, &val);
		--r;
		--c;
	}
};

int n;
int R, C;
vector<pnt> ps;
vector<pair<int, ll>> g[MAXN];

bool read() {
	if  (scanf("%d%d", &R, &C) < 2) {
		return false;
	}
	scanf("%d", &n);
	ps.resize(n);
	forn(i, n) {
		ps[i].read();
	}
	forn(i, R + C) {
		g[i].clear();
	}
	return true;
}

vector<pll> vals;
bool was[MAXN];

void addE(int v, int u, ll sum) {
	assert(v != u);
	g[v].pb(mp(u, sum));
	g[u].pb(mp(v, sum));
}

bool dfs(int v, ll& low, ll& up, vi& vs) {
	was[v] = true;
	vs.pb(v);

	ll a, b;
	tie(a, b) = vals[v];
	if  (a == 0) {
		if (b < 0) {
			return false;
		}
	} else if  (a > 0) {
		low = max(low, (-b + a - 1) / a);
	} else {
		assert(a < 0);
		up = min(up, b / (-a));
	}

	for (const auto& e : g[v]) {
		int to = e.fst;
		ll sum = e.snd;
		if  (was[to]) {
			ll c, d;
			tie(c, d) = vals[to];
			ll left = a + c;
			ll right = sum - (b + d);
			if  (left == 0) {
				if  (right != 0) {
					return false;
				}
			} else {
				if  (right % left != 0) {
					return false;
				}
				low = max(low, right / left);
				up = min(up, right / left);
			}
		} else {
			vals[to].fst = -a;
			vals[to].snd = -b + sum;
			if  (!dfs(to, low, up, vs)) {
				return false;
			}
		}
	}
	return true;
} 

bool solve(int v) {
	vals[v] = mp(1, 0);
	ll low = -INF;
	ll up = INF;
	vi vs;
	if  (!dfs(v, low, up, vs)) {
		return false;
	}
	if  (low > up) {
		return false;
	}

	ll x = low;
	for (auto u : vs) {
		vals[u].snd = vals[u].fst * x + vals[u].snd;
		vals[u].fst = 0;
	}
	return true;
}

bool solve() {
	vals.assign(R + C, mp(-1, -1));
	forn(i, R + C) {
		g[i].clear();
	}
	forn(i, n) {
		int v = ps[i].r;
		int u = R + ps[i].c;
		addE(v, u, ps[i].val);
	}

	memset (was, 0, sizeof was);
	forn(v, R + C) {
		if  (!was[v]) {
			if (!solve(v)) {
				return false;
			}
		}
	}

	// forn(i, R + C) {
	// 	assert(vals[i].fst == 0);
	// 	printf("%lld\n", vals[i].snd);
	// }

	return true;
}

int main() {
#ifdef LOCAL
	freopen(FILE_NAME ".in", "r", stdin);
	// freopen(FILE_NAME ".out", "w", stdout);
#endif

	while (read()) {
		puts(solve() ? "Yes" : "No");
	}

#ifdef LOCAL
	cerr.precision(5);
	cerr << "Time: " << fixed << (double) clock() / CLOCKS_PER_SEC << endl;
#endif
	return 0;
}


Measured memory_bytes: 29432