package main

import . "fmt"
import . "os"
import bf "bufio"

type Req struct {
	x,a,b int
}

type Res struct {
	a, b int
}

func main() {
	rd:=bf.NewReader(Stdin)
	wr:=bf.NewWriter(Stdout)
	defer wr.Flush()
	
	var n,p,q int
	Fscan(rd,&n,&p,&q)
	rs := make([]*Req, n)
	for i := range rs {
		var x,a,b int
		Fscan(rd,&x,&a,&b)
		rs[i] = &Req{x,a,b}
	}
	
	ans := solve(n,p,q,rs)
	if len(ans) == 0 {
		Fprintln(wr,"No")
	} else {
		Fprintln(wr,"Yes")
		for _, r := range ans {
			Fprintln(wr, r.a, r.b)
		}
	}
}

func solve(n, p, q int, rs []*Req) []*Res {
	sum := 0
	for _, r := range rs {
		if r.a+r.b < r.x {
			return nil
		}
		sum += r.x
	}
	if sum > p+q {
		return nil
	}
	ans := make([]*Res, n)
	for i := range ans {
		ans[i] = new(Res)
	}
	for i, r := range rs {
		if r.a < r.b {
			if r.a < r.x {
				nb := r.x - r.a
				if q < nb {
					return nil
				}
				ans[i].b = nb
				q -= nb
			}
		} else if r.b < r.x {
			na := r.x - r.b
			if p < na {
				return nil
			}
			ans[i].a = na
			p -= na
		}
	}
	for i, r := range rs {
		s := ans[i]
		if p > 0 && s.a+s.b<r.x && r.a-s.a > 0 {
			c := min(p, r.x-s.a-s.b, r.a-s.a)
			s.a += c
			p -= c
		} 
		if q > 0 && s.a+s.b<r.x && r.b-s.b > 0 {
			c := min(q, r.x-s.a-s.b, r.b-s.b)
			s.b += c
			q -= c
		}
		if s.a+s.b < r.x {
			return nil
		}
	}
	return ans
}