{-# LANGUAGE ScopedTypeVariables #-}
import Control.Applicative
import Control.Monad
import Control.Monad.State
import Control.DeepSeq
import Data.Array
import Data.Bits
import Data.Char
import Data.Functor.Identity
import Data.List
import Data.Maybe
import Data.Ord
import Data.Tree
import Data.Tuple
import qualified System.IO
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.Sequence as Q
import qualified Data.ByteString.Char8 as B

import Data.Array.IO
import Data.IORef

huge = 1000111222333444

main = do
  [r,c] <- getInts
  n <- getInt
  es <- replicateM n getInts
  let es1 = accumArray (flip(:)) [] (1,r) [(i,(j,x)) | [i,j,x]<-es]
  let es2 = accumArray (flip(:)) [] (1,c) [(j,(i,x)) | [i,j,x]<-es]
  -- print (es1,es2)
  valL :: IOArray Z (Maybe Z) <- newArray (1,r) Nothing
  valR :: IOArray Z (Maybe Z) <- newArray (1,c) Nothing
  ans <- newIORef True
  let
    go1 i x = do
      lrs <- forM (es1!i) $ \ (j,z) -> do
        my <- readArray valR j
        case my of
          Nothing -> do
            writeArray valR j (Just (z-x))
            go2 j (z-x)
          (Just y) -> do
            when (x+y /= z) $ writeIORef ans False
            return (huge, huge)
      let ls = map fst lrs
      let rs = map snd lrs
      return (minimum (x:ls), minimum (huge:rs))
    go2 j y = do
      lrs <- forM (es2!j) $ \ (i,z) -> do
        mx <- readArray valL i
        case mx of
          Nothing -> do
            writeArray valL i (Just (z-y))
            go1 i (z-y)
          (Just x) -> do
            when (x+y /= z) $ writeIORef ans False
            return (huge, huge)
      let ls = map fst lrs
      let rs = map snd lrs
      return (minimum (huge:ls), minimum (y:rs))
  forM_ [1..r] $ \ i -> do
    mx <- readArray valL i
    case mx of
      Just _ -> return ()
      Nothing -> do
        writeArray valL i (Just 0)
        (lft, rgt) <- go1 i 0
        when (lft + rgt < 0) $ writeIORef ans False
  ans' <- readIORef ans
  putStrLn $ yesNo ans'



 
type Z = Int
type Q = Rational
type R = Double
type S = String

fint :: (Integral a, Num b) => a -> b
fint = fromIntegral

getInt = fst . fromJust . B.readInt <$> B.getLine
getIntPair = (\[a,b]->(a,b)) <$> getInts
getInts = map (fst . fromJust . B.readInt) . B.words <$> B.getLine
getStr = B.unpack <$> B.getLine

yesNo :: Bool -> String
yesNo True = "Yes"
yesNo False = "No"

printList :: (Show a) => [a] -> IO ()
printList = putStrLn . unwords . map show

readLnList :: (Read a) => IO [a]
readLnList = map read . words <$> getLine


-----  Union-find
type UnionFindT v m a = StateT (M.Map v (UnionFindVal v)) m a
newtype UnionFindVal v = UnionFindVal v

runUnionFindT :: (Monad m) => UnionFindT v m a -> m a
runUnionFindT = flip evalStateT $ M.empty

runUnionFind = runIdentity . runUnionFindT

ufFresh :: (Monad m, Ord v) => v -> UnionFindT v m ()
ufFresh v = modify $ M.insert v (UnionFindVal v)

ufClass :: (Monad m, Ord v) => v -> UnionFindT v m v
ufClass v = do
  (UnionFindVal pv) <- gets (M.! v)
  if v == pv
    then return v
    else do
      c <- ufClass pv
      modify $ M.insert v (UnionFindVal c)
      return c

ufUnify v w = do
  cv <- ufClass v
  cw <- ufClass w
  modify $ M.insert cw (UnionFindVal cv)
  return $ cv /= cw
