#include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <tuple>
#include <cassert>
#define repeat(i,n) for (int i = 0; (i) < (n); ++(i))
#define whole(f,x,...) ([&](decltype((x)) y) { return (f)(begin(y), end(y), ## __VA_ARGS__); })(x)
typedef long long ll;
using namespace std;
template <class T> void setmin(T & a, T const & b) { if (b < a) a = b; }

const ll inf = ll(1e18)+9;
int main() {
    // input
    int h, w; scanf("%d%d", &h, &w);
    int n; scanf("%d", &n);
    vector<tuple<int,int,int> > q(n);
    map<int,map<int,int> > fh;
    map<int,map<int,int> > fw;
    repeat (i,n) {
        int y, x, a; scanf("%d%d%d", &y, &x, &a); -- y; -- x;
        q[i] = { y, x, a };
        fh[y][x] = a;
        fw[x][y] = a;
    }
    // compute
    bool ans = true;
    vector<ll> ph(h, inf);
    vector<ll> pw(w, inf);
    auto go = [&](int sy, int sx, int sa) {
        assert (ans);
        assert (ph[sy] == inf);
        assert (pw[sx] == inf);
        queue<tuple<int,int> > que;
        vector<bool> usedh(h, false);
        vector<bool> usedw(w, false);
        set<int> usedys;
        set<int> usedxs;
        que.push(make_tuple(sy, sx));
        ph[sy] = sa; pw[sx] = 0;
        while (not que.empty()) {
            int y, x; tie(y, x) = que.front(); que.pop();
            int a = fh[y][x];
            usedys.insert(y);
            usedxs.insert(x);
            if (pw[x] != inf and not usedh[y]) {
                usedh[y] = true;
                for (auto it : fh[y]) {
                    int nx, na; tie(nx, na) = it;
                    if (pw[nx] == inf) {
                        assert (pw[x] != inf);
                        pw[nx] = pw[x] - a + na;
                        if (not usedw[nx]) que.push(make_tuple(y, nx));
                    } else {
                        if (pw[nx] != pw[x] - a + na) { ans = false; return; }
                    }
                }
            }
            if (ph[y] != inf and not usedw[x]) {
                usedw[x] = true;
                for (auto it : fw[x]) {
                    int ny, na; tie(ny, na) = it;
                    if (ph[ny] == inf) {
                        ph[ny] = ph[y] - a + na;
                        if (not usedh[ny]) que.push(make_tuple(ny, x));
                    } else {
                        if (ph[ny] != ph[y] - a + na) { ans = false; return; }
                    }
                }
            }
        }
        ll minh = inf; for (int y : usedys) setmin(minh, ph[y]);
        ll minw = inf; for (int x : usedxs) setmin(minw, pw[x]);
        if (minh + minw < 0) { ans = false; return; }
        if (minh < 0) {
            for (int y : usedys) if (ph[y] != inf) ph[y] -= minh;
            for (int x : usedxs) if (pw[x] != inf) pw[x] += minh;
        } else if (minw < 0) {
            for (int y : usedys) if (ph[y] != inf) ph[y] += minw;
            for (int x : usedxs) if (pw[x] != inf) pw[x] -= minw;
        }
    };
    repeat (i,n) {
        int y, x, a; tie(y, x, a) = q[i];
        if (ph[y] == inf and pw[x] == inf) {
            go(y, x, a);
        }
        if (not ans) break;
        if (ph[y] == inf) ph[y] = a - pw[x];
        if (pw[x] == inf) pw[x] = a - ph[y];
        if (a != ph[y] + pw[x]) { ans = false; break; }
    }
    if (ans) {
        if (*whole(min_element, ph) + *whole(min_element, pw) < 0) ans = false;
    }
    // output
    printf("%s\n", ans ? "Yes" : "No");
    return 0;
}


Measured memory_bytes: 28032