object Main extends App {

  import scala.io.StdIn._
  import scala.math._


  val Array(n, m, q) = readLine.trim.split(' ').map(_.toInt)
  val floors = SegTree(1, n)
  for (_ ← 0 until m) {
    val Array(d, a, b) = readLine.trim.split(' ').map(_.toInt)
    floors.setUpperLimit(a, b, d)
  }
  for (_ ← 0 until q){
    val Array(e, s, t) = readLine.trim.split(' ').map(_.toInt)
    println(
      if (floors.maxBetween(s, t) < e) "Yes"
      else "No"
    )
  }
  object SegTree{
    def apply(from: Int, to: Int, default: Int = Int.MaxValue): SegTree = {
      if (from == to) new Leaf(default, from)
      else new Node(from, to, SegTree(from, (from + to) / 2, default), SegTree((from + to) / 2 + 1, to, default))
    }
  }
  sealed trait SegTree{
    def maxBetween(from: Int, to: Int): Int
    def setUpperLimit(from: Int, to: Int, limit: Int): Unit
    def upper: Int
  }
  class Node(private val mFrom: Int, private val mTo: Int, private val mLeft: SegTree, private val mRight: SegTree) extends SegTree {
    override def upper: Int = mUpper
    private var mUpper = math.max(mLeft.upper, mRight.upper)

    override def setUpperLimit(from: Int, to: Int, limit: Int): Unit = {
      if (mUpper > limit) {
        if (from <= mFrom && mTo <= to) {
          mUpper = limit
        } else if (from <= mTo && mFrom <= to) {
          mLeft.setUpperLimit(from, to, limit)
          mRight.setUpperLimit(from, to, limit)
          mUpper = math.max(mLeft.upper, mRight.upper)
        }
      }
    }
    override def maxBetween(from: Int, to: Int): Int = {
      if (to < mFrom || mTo < from) Int.MinValue
      else if (from <= mFrom && mTo <= to) mUpper
      else {
        mLeft.setUpperLimit(mFrom, mTo, mUpper)
        mRight.setUpperLimit(mFrom, mTo, mUpper)
        math.max(mLeft.maxBetween(from, to), mRight.maxBetween(from, to))
      }
    }
  }
  class Leaf(private var mValue: Int, private val mPosition: Int) extends SegTree {
    override def maxBetween(from: Int, to: Int): Int = {
      if ((from to to).contains(mPosition)) mValue
      else Int.MinValue
    }

    override def setUpperLimit(from: Int, to: Int, limit: Int): Unit = {
      if ((from to to).contains(mPosition) && limit < mValue) mValue = limit
    }

    override def upper: Int = mValue
  }
  implicit class Extension[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}
