{-# LANGUAGE OverloadedLists     #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE ScopedTypeVariables #-}

import           Control.Monad
--import           Control.Monad.Loops
import           Data.IORef
import           Data.Maybe
import qualified Data.Text     as T
import qualified Data.Text.IO  as T
import           GHC.Base
import           System.IO

import qualified Data.Array    as A
import qualified Data.IntMap   as I
import           Data.List
import qualified Data.Map      as M
import qualified Data.Set      as S
import qualified Data.Vector   as V

-- for Text
(+.+) = T.append
(!.!) = T.index

-- for Vector
count :: (a -> Bool) -> V.Vector a -> Int
count p = V.length . V.filter p

-- for IO
readT :: Read a => T.Text -> a
readT = read . T.unpack

getLineSpc :: Read a => IO [a]
getLineSpc = do
  t <- T.getLine
  let xs = map readT $ T.split (== ' ') t
  return xs

getLineSpcVec :: Read a => IO (V.Vector a)
getLineSpcVec = do
  t <- T.getLine
  let xs = V.fromList $ map readT $ T.split (== ' ') t
  return xs

----------
-- main --
----------
main :: IO ()
main = traveling

traveling :: IO ()
traveling = do
  n :: Int <- readLn
  txys' :: [[Int]]  <- replicateM n getLineSpc
  let txys = [0, 0, 0] : txys'
  bools <- newIORef []
  forM_ ([1..n] :: [Int]) $ \i ->
     modifyIORef bools (isPossibleRoute (txys !! (i - 1)) (txys !! i) :)
  bools <- readIORef bools
  if and bools
    then
    putStrLn "Yes"
    else
    putStrLn "No"

isPossibleRoute :: [Int] -> [Int] -> Bool
isPossibleRoute txy1 txy2
  | diff >= 0  && even diff = True
  | otherwise               = False
 where
   diff = (t2 - t1) - abs (x2 - x1) - abs (y2 - y1)
   [t1, x1, y1] = txy1
   [t2, x2, y2] = txy2