#include <bits/stdc++.h>

#define clr(x) memset((x), 0, sizeof(x))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define x first
#define y second
#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 for1(i, n) for(int i = 1; i <= (int)(n); ++i)

using namespace std;

typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<long long> vll;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;

const ld PI = 3.1415926535897932384626433832795L;

template<class T>
bool uin(T &, const T &);

template<class T>
bool uax(T &, const T &);

template<class T>
T gcd(T, T);

template<class T>
T lcm(T, T);

template<class _T>
inline string tostr(const _T &);

template<typename T>
void input(T &);

template<typename T = long long>
T nxt();

bool checkp(long long);

template <typename T>
T pw(T a, T n, T p);

template <typename T>
T inv(T a, T p);

void pre() {

}

vector <pair <int, ll> > g[1 << 20];
vector <pair <int, ll> > gr[1 << 20];

ll s1[1 << 20];
ll s2[1 << 20];

int c1[1 << 20];
int c2[1 << 20];

void NO() {
    cout << "No\n";
    exit(0);
}

ll m1[1 << 20];
ll m2[1 << 20];

void dfs2(int v, ll s, int c);

void dfs1(int v, ll s, int c) {
    s1[v] = s;
    c1[v] = c;
    m1[c] = min(m1[c], s1[v]);

    for (auto to : g[v]) {
        if (s2[to.x] != -1) {
            if (s2[to.x] != to.y - s) {
                NO();
            }
        } else {
            dfs2(to.x, to.y - s, c);
        }
    }
}

void dfs2(int v, ll s, int c) {
    s2[v] = s;
    c2[v] = c;
    m2[c] = min(m2[c], s2[v]);
//    cerr << c << " ! " << m2[c] << endl;
    for (auto to : gr[v]) {
        if (s1[to.x] != -1) {
            if (s1[to.x] != to.y - s) {
                NO();
            }
        } else {
            dfs1(to.x, to.y - s, c);
        }
    }
}

void solve(int test) {
    int r = nxt();
    int c = nxt();
    int n = nxt();

    vector<pair<pii, ll >> z;

    forn(i, n) {
        int x = nxt() - 1;
        int y = nxt() - 1;
        ll v = nxt();
        g[x].push_back(mp(y, v));
        gr[y].push_back(mp(x, v));
        z.push_back(mp(mp(x, y), v));
    }

    memset(s1, 255, sizeof(s1));
    memset(s2, 255, sizeof(s2));

    memset(m1, 0x3f, sizeof(m1));
    memset(m2, 0x3f, sizeof(m2));


    int cnt = 0;

    dfs2(0, 0, cnt++);

    for (int i = 0; i < c; ++i) {
        if (s2[i] == -1) {
            dfs2(i, 0, cnt++);
        }
    }

    for (int i = 0; i < r; ++i) {
        if (s1[i] == -1) {
            dfs1(i, 0, cnt++);
        }
    }



    for (int i = 0; i < cnt; ++i) {
        if (m1[i] + m2[i] < 0) {
            NO();
        }
    }
//    forn(i, r) cerr << s1[i] << " ";
//    cerr << endl;
//
//    forn(i, c) cerr << s2[i] << " ";
//    cerr << endl;

    cout << "Yes\n";

}




int main(int argc, char **argv) {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#else
    #define fname "sequence"
    //freopen(fname".in", "r", stdin);
    //freopen(fname".out", "w", stdout);
#endif
    pre();
    int t = 1;
#ifdef LOCAL
#else
#endif
    for (int test = 1; test <= t; ++test) {
        solve(test);
    }

#ifdef LOCAL
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif
    return 0;
}


template<typename T>
T gcd(T x, T y) {
    while (y > 0) {
        x %= y;
        swap(x, y);
    }
    return x;
}

template<class T>
T lcm(T a, T b) {
    return a / gcd(a, b) * b;
}


template<class _T>
inline _T sqr(const _T &x) {
    return x * x;
}

template<class _T>
inline string tostr(const _T &a) {
    ostringstream os("");
    os << a;
    return os.str();
}


template<typename T>
inline void input(T &a) {
    static int ed;
    a = 0;
    while (!isdigit(ed = getchar()) && ed != '-') {}
    char neg = 0;
    if (ed == '-') {
        neg = 1;
        ed = getchar();
    }
    while (isdigit(ed)) {
        a = 10 * a + ed - '0';
        ed = getchar();
    }
    if (neg) a = -a;
}

template<typename T = long long>
inline T nxt() {
    T res;
    input(res);
    return res;
}

void myassert(bool v) {
    assert(v);
    //cout << "FAIL\n";
    //exit(0);
}

mt19937 generator;

bool checkp(long long v) {
    if (v < 2) return false;
    for (long long i = 2; i * i <= v; ++i) {
        if (v % i == 0) {
            return false;
        }
    }
    return true;
}
template <typename T>
T pw(T a, T n, T m) {
    T res = 1;
    while (n) {
        if (n & 1) {
            res = res * a % m;
        }
        a = a * a % m;
        n >>= 1;
    }
    return res;
}

template <typename T>
T inv(T a, T p) {
    T res = 1;
    while (a > 1) {
        res = res * (p - p / a) % p;
        a = p % a;
    }
    return res;
}


template<class T>
bool uin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool uax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}

Measured memory_bytes: 94448