#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define int long long
#define INF 1000000000000000000
using namespace std;

typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int, int> Pii;

#define ANS(f) if(f) cout << "YES" << endl; else cout << "NO" << endl;

template<typename T>
void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readi(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }

struct edge{int to, cost;};

class Graph
{
public:
    int V;
    vector<vector<edge>> G;

    Graph(int V): V(V){
        G = vector<vector<edge>>(V, vector<edge>(0));
    }

    void add_edge(int from, int to, int cost){
        G[from].push_back(edge({to, cost}));
    }

    void add_edge2(int v1, int v2, int cost){
        add_edge(v1, v2, cost);
        add_edge(v2, v1, cost);
    }

    bool dfs(vector<bool> &used, int &M, int &m, int s, int v, vec &val, int c, vec &par){
        used[v] = true;
        val[v] = c;
        par[v] = s;
        M = max(M, c);
        m = min(m, c);
        REP(i, G[v].size()){
            if(used[G[v][i].to]){
                if(val[G[v][i].to] != val[v] + G[v][i].cost) return false;
            }
            else{
                if(!dfs(used, M, m, s, G[v][i].to, val, c + G[v][i].cost, par)) return false;
            }
        }
        return true;
    }

};

signed main(){

    int R, C; cin >> R >> C;
    int N; cin >> N;
    vec r(N), c(N), a(N);
    vector<map<int, int>> m(R);
    map<Pii, int> dif;
    REP(i, N){
        cin >> r[i] >> c[i] >> a[i];
        r[i]--;
        c[i]--;
        m[r[i]][c[i]] = a[i];
    }

    REP(i, R){
        Pii q = Pii(-INF, -INF);
        for(auto p: m[i]){
            if(q.first == -INF){
                q = p;
                continue;
            }
            if(dif.count(Pii(q.first, p.first)) > 0){
                if(dif[Pii(q.first, p.first)] != p.second - q.second){
                    cout << "No" << endl;
                    return 0;
                }
            }else{
                dif[Pii(q.first, p.first)] = p.second - q.second;
            }
            q = p;
        }
    }

    Graph G(C);
    for(auto p: dif){
        G.add_edge(p.first.first, p.first.second, p.second);
        G.add_edge(p.first.second, p.first.first, -p.second);
        //cout << p.first.first << " " << p.first.second << " " << p.second << endl;
    }
    vector<bool> used(C, false);
    int M0, m0;
    vec vM(C), vm(C), par(C), val(C);

    REP(i, C){
        if(used[i]) continue;
        M0 = -INF;
        m0 = INF;
        if(!G.dfs(used, M0, m0, i, i, val, 0, par)){
            cout << "No";
            return 0;
        }
        vM[i] = M0;
        vm[i] = m0;
    }

    REP(i, N){
        //cout << vm[par[c[i]]] << endl;
        //cout << val[c[i]] << endl;
        m0 = vm[par[c[i]]] - val[c[i]];
        if(a[i] + m0 < 0){
            cout << "No";
            return 0;
        }
    }
    cout << "Yes";
    
    return 0;
}

Measured memory_bytes: 27392