//  [cpp]
#include <cstdio>
#include <cstring>
#include <cstdint>
#include <cstdlib>
#include <cstddef>
#include <cmath>

#include <type_traits>

namespace FastIn {
  static constexpr size_t BUF_SIZE=1<<17, INT_LEN=24, FLT_LEN=400;
  static char buf[BUF_SIZE|1]={}, *pos=buf, *endbuf=nullptr;

  inline bool rebuffer() {
    size_t rest=endbuf-pos;
    if (rest+buf > pos) {
      // not disjoint
      return true;
    }

    std::memcpy(buf, pos, rest); 
    pos = buf;
    size_t len=std::fread(pos+rest, 1, BUF_SIZE-rest, stdin);
    *(endbuf = buf + (rest+len)) = 0;

    return *pos;
  }

  inline bool scan(unsigned &in) {
    if (pos + INT_LEN >= endbuf && !rebuffer()) {
      return false;
    }

    asm (
      ""
      "movsbl (%2), %%eax;"
      "leaq (%2), %%rdx;"
      "xorl %%esi, %%esi;"
      "jmp SCAN_FIRST%=;"

    "SCAN%=:"
      "leaq 1(%%rdx), %%rdx;"
    "SCAN_FIRST%=:"
      "leal (%%rsi, %%rsi, 4), %%ecx;"
      "leal -48(%%rax, %%rcx, 2), %%esi;"
      "movsbl 1(%%rdx), %%eax;"
      "cmpb $47, %%al;"
      "jg SCAN%=;"
      "movl %%esi, %0;"
      "leaq 2(%%rdx), %1;"
      : "=r" (in), "=r" (pos)
      : "1" (pos)
      : "%rax", "%rdx", "%rsi", "%rcx"
    );

    return true;
  }

  class Scanner {
    bool rebuffer() {
      return FastIn::rebuffer();
    }

  public:
    Scanner() {
      endbuf = pos + std::fread(buf, 1, BUF_SIZE, stdin);
    }

    template <class T>
    inline bool scan(T &in) {
      return FastIn::scan(in);
    }

    template <class First, class... Rest>
    inline bool scan(First &in, Rest &...ins) {
      return scan(in) && scan(ins...);
    }
  };
}

namespace FastOut {
  static constexpr size_t BUF_SIZE=1<<17, INT_LEN=24, FLT_LEN=400;
  static constexpr char FLT_FMT[]="%.16f";
  static char buf[BUF_SIZE|1]={}, *pos=buf, *endbuf=pos+BUF_SIZE;
  FILE *fout;

  inline void flush() {
    std::fwrite(buf, 1, pos-buf, fout);
    pos = buf;
  }

  inline void print(const char out) {
    if (pos == endbuf) {
      flush();
    }
    *pos++ = out;
  }

  template <class Int>
  inline void print(
      Int out,
      typename std::enable_if<std::is_signed<Int>::value>::type *un=nullptr
  ) {
    if (out == 0) {
      if (pos == endbuf) {
        flush();
      }
      *pos++ = '0';
      return;
    }

    char minibuf[INT_LEN], *minipos=minibuf+INT_LEN;
    if (out < 0) {
      if (pos == endbuf) {
        flush();
      }
      *pos++ = '-';
      if (__builtin_popcount(out) == 1) {
        // maximum-magnitude negative integer in two's complement expression
        // Regardless of the number of the bits, lowest (decimal) digit is
        // always eight, but other digits depend on it.
        *--minipos = '8';
        out /= 10;
      }
      out = -out;
    }

    while (out > 0) {
      *--minipos = '0' + out%10;
      out /= 10;
    }
    size_t len=(minibuf+INT_LEN)-minipos;
    if (pos + len >= endbuf) {
      flush();
    }
    std::memcpy(pos, minipos, len);
    pos += len;
  }

  template <class Int>
  inline void print(
      Int out,
      typename std::enable_if<!std::is_signed<Int>::value>::type *un=nullptr
  ) {
    if (out == 0) {
      if (pos == endbuf) {
        flush();
      }
      *pos++ = '0';
      return;
    }

    char minibuf[INT_LEN], *minipos=minibuf+INT_LEN;
    while (out > 0) {
      *--minipos = '0' + out%10;
      out /= 10;
    }
    size_t len=(minibuf+INT_LEN)-minipos;
    if (pos + len >= minibuf) {
      flush();
    }
    std::memcpy(pos, minipos, len);
    pos += len;
  }

  template <class First, class... Rest>
  inline void print(const First &out, const Rest &...outs) {
    print(out);
    print(outs...);
  }

  class Printer {
    inline void flush() {
      FastOut::flush();
    }

  public:
    Printer(FILE *fout=stdout) {
      FastOut::fout = fout;
    }

    ~Printer() {
      flush();
    }

    template <class T>
    inline void print(const T out) {
      FastOut::print(out);
    }

    template <class First, class... Rest>
    inline void print(const First &&out, const Rest &&...outs) {
      print(out);
      print(outs...);
    }

    template <class T>
    inline void println(const T out) {
      print(out);
      print('\n');
    }
  };
}

FastIn::Scanner cin;
//FastOut::Printer cout;

int main() {
  unsigned N;
  cin.scan(N);

  for (unsigned i=0; i<N; ++i) {
    unsigned t, x, y;
    cin.scan(t, x, y);

    if ((t+x+y) & 1 || t < x+y)
      return !printf("No\n");
  }

  //cout.println(res);
  puts("Yes");
}