#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <queue>
#include <set>
#include <map>
#include <deque>
#include <iomanip>
#include <cstdio>
#include <stack>
#include <numeric>

using namespace std;
typedef  long long ll;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define  MP make_pair
#define  PB push_back
#define inf 1000000007
#define mod 1000000007
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define int long long
class UnionFind {
private:
    int sz;
    vector<int> par, size_;
public:
    UnionFind(){}
    UnionFind(int node_size) : sz(node_size), par(sz), size_(sz, 1){
        iota(par.begin(), par.end(), 0);
    }
    int find(int x){
        if(par[x] == x) return x;
        else return par[x] = find(par[x]);
    }
    void unite(int x,int y){
        x = find(x), y = find(y);
        if(x == y) return;
        if(size_[x] < size_[y]) swap(x,y);
        par[y] = x;
        size_[x] += size_[y];
    }
    int size(int x){
        x = find(x);
        return size_[x];
    }
    bool same(int x,int y){
        return find(x) == find(y);
    }
};
template<typename T> class Weighted_UnionFind
{
public:
    int V;
    vector<int> par,nrank;
    vector<T> wd;
    Weighted_UnionFind(int node_size) : V(node_size), par(V), nrank(V, 0), wd(V, 0){
        iota(par.begin(), par.end(), 0);
    }
    int find(int x){
        if(par[x] == x){
            return x;
        }else{
            int parent = find(par[x]);
            wd[x] += wd[par[x]];
            return par[x] = parent;
        }
    }
    T weight(int x){
        find(x);
        return wd[x];
    }
    void unite(int x,int y,T w){
        w += weight(x), w -= weight(y);
        x = par[x], y = par[y];
        if(x == y) return;
    	if(nrank[x] < nrank[y]){
            swap(x,y);
            w = -w;
        }
        nrank[x] += (nrank[x] == nrank[y]);
        par[y] = x;
        wd[y] = w;
    }
    bool same(int x,int y){
        return find(x) == find(y);
    }
    T diff(int x,int y){
        return weight(y) - weight(x);
    }
};

signed main(){
    int r,c;
    int n;
    cin >> r >> c;
    cin >> n;
    vector<pair<pair<int,int>,pair<int,int> > > p(n);
    vector<pair<pair<int,int>,pair<int,int> > > q(n);
    
    rep(i,n){
        int x,y,z;
        cin >> x >> y >> z;
        p[i] = MP(MP(x,y),MP(z,i));
        q[i] = MP(MP(y,x),MP(z,i));
    }
    sort(p.begin(),p.end());
    sort(q.begin(),q.end());
    UnionFind uf(100005);
    Weighted_UnionFind<ll> wfx(100005);
    Weighted_UnionFind<ll> wfy(100005);
    bool flag = 0;
    rep(i,n){
        if(i==0)continue;
        int x = p[i].first.first;
        int y = p[i].first.second;
        int w = p[i].second.first;
        int id = p[i].second.second;
        int xx = p[i-1].first.first;
        int yy = p[i-1].first.second;
        int ww = p[i-1].second.first;
        int idd = p[i-1].second.second;
        if(x==xx){
            uf.unite(id,idd);
            if(wfy.same(y,yy)){
                if(wfy.diff(y,yy)!=ww-w){
                    flag = 1;
                }
            }else{
                wfy.unite(y,yy,ww-w);
            }
        }
    }
    rep(i,n){
        if(i==0)continue;
        int x = q[i].first.first;
        int y = q[i].first.second;
        int w = q[i].second.first;
        int id = q[i].second.second;
        int xx = q[i-1].first.first;
        int yy = q[i-1].first.second;
        int ww = q[i-1].second.first;
        int idd = q[i-1].second.second;
         if(x==xx){
            uf.unite(id,idd);
            if(wfx.same(y,yy)){
                if(wfx.diff(y,yy)!=ww-w){
                    flag = 1;
                }
            }else{
                wfx.unite(y,yy,ww-w);
            }
        }
    }
    if(flag){
        cout << "No" << endl;
        return 0;
    }
    //cerr << "test" << endl;
    vector<pair<pair<int,int>,pair<int,int> > > v[100005];
    rep(i,n){
        v[uf.find(p[i].second.second)].push_back(p[i]);
    }
    rep(i,100005){
        if(v[i].size()>=2){
            ll xm = 0;
            ll ym = 0;
            rep(k,v[i].size()){
                if(k==0)continue;
                int x = v[i][0].first.first;
                int y = v[i][0].first.second;
                int xx = v[i][k].first.first;
                int yy = v[i][k].first.second;
                if(x!=xx){
                    xm = min(xm,wfx.diff(x,xx));
                }
                if(y!=yy){
                    ym = min(ym,wfy.diff(y,yy));
                }
            }
            if(v[i][0].second.first + xm + ym<0){
                flag = 1;
            }
            //cerr << v[i][0].second.first << " " << xm << " " << ym << endl;
        }
    }
    if(flag){
        cout << "No" << endl;
    }else{
        cout << "Yes" << endl;
    }
    return 0;
}

Measured memory_bytes: 21360