// Arup Guha
// 10/9/2017
// Solution to 2017 NAQ Problem A: Birthday Cake

import java.util.*;

public class birthdaycake_arup {

	public static int nPts;
	public static int nLines;
	public static int r;
	public static line[] cuts;
	public static pt[] candles;

	public static void main(String[] args) {

		Scanner stdin = new Scanner(System.in);
		nPts = stdin.nextInt();
		nLines = stdin.nextInt();
		r = stdin.nextInt();

		// Read in the candles.
		candles = new pt[nPts];
		for (int i=0; i<nPts; i++) {
			int x = stdin.nextInt();
			int y = stdin.nextInt();
			candles[i] = new pt(x,y);
		}

		// Read in the lines.
		cuts = new line[nLines];
		for (int i=0; i<nLines; i++) {
			int a = stdin.nextInt();
			int b = stdin.nextInt();
			int c = stdin.nextInt();
			cuts[i] = new line(a,b,c,r);
		}

		// Solve it!
		System.out.println(canDo());
	}

	public static String canDo() {

		// V - E + F = 2

		// We are guaranteed that each line cuts the cake outer edge twice.
		int vertices = 2*nLines;
		int edges = 2*nLines;

		// Store number of intersections with each line here.
		int[] numInter = new int[nLines];

		// Count the number of intersections between the lines, completing our vertex count.
		for (int i=0; i<nLines; i++) {
			for (int j=i+1; j<nLines; j++) {
				if (cuts[i].intersect(cuts[j])) {
					vertices++;
					numInter[i]++;
					numInter[j]++;
				}
			}
		}

		// Add in number of edges formed by each line.
		for (int i=0; i<nLines; i++)
			edges += (numInter[i]+1);

		// Euler's Theorem says the number of faces of a planar graph is E - V + 2. If there is one candle per
		// piece, then there is the "outer face" that isn't counted, so the faces must equal candles + 1.
		if (edges - vertices + 2 != nPts + 1)
			return "no";

		// Go through each pair of candles.
		for (int i=0; i<nPts; i++) {
			for (int j=i+1; j<nPts; j++) {

				// Line segment from candle i to candle j.
				line tmp = new line(candles[i], candles[j]);

				boolean cross = false;

				// If this triggers, then the line segment between candles i and j intersects cut line k.
				// This means the candles are on two different pieces.
				for (int k=0; k<nLines; k++) {
					if (tmp.intersect(cuts[k])) {
						cross = true;
						break;
					}
				}

				// We never triggered so candles i and j are on the same piece.
				if (!cross) return "no";
			}
		}

		// If we get here, we're good - correct # of pieces and no two candles on one piece!
		return "yes";
	}
}

class pt {

	public double x;
	public double y;

	public pt(double myx, double myy) {
		x = myx;
		y = myy;
	}

	public pt subtract(pt start) {
		return new pt(x-start.x, y-start.y);
	}

	public pt add(pt other) {
		return new pt(x+other.x, y+other.y);
	}

	public double mag() {
		return Math.sqrt(x*x+y*y);
	}

	public double crossMag(pt other) {
		return x*other.y - y*other.x;
	}

	public String toString() {
		return "("+x+","+y+")";
	}
}

class line {

	public pt p;
	public pt dir;

	// Create a line segment between the 2 pts on ax + by + c = 0 on the circle x^2+y^2=r^2.
	public line(int a, int b, int c, int r) {

		if (b == 0) {
			double x = -1.0*c/a;
			double y = Math.sqrt(r*r-x*x);
			p = new pt(x, y);
			dir = new pt(0, -2*y);
			return;
		}

		//y   = (-c-ax)/b
		// x^2 + y^2 = r^2
		// x^2 + (a^2x^2 + 2acx + c^2)/b^2 = r^2*b^2

		// Solve for y in line equation: y = (-a/b)x -(c/b) Then sub into circle equation.
		// Let the circle equation be a quadratic in x with coefficients c2, c1 and c0.
		double c2 = b*b+a*a;
		double c1 = 2.0*a*c;
		double c0 = c*c-r*r*b*b;
		double disc = c1*c1 - 4*c2*c0;

		// Solve for both points x1, and x2, x-coordinates of intersection points.
		// We can get y by plugging into the line equation.
		double x1 = (-c1 + Math.sqrt(disc))/(2*c2);
		double y1 = (-c-a*x1)/b;
		double x2 = (-c1 - Math.sqrt(disc))/(2*c2);
		double y2 = (-c-a*x2)/b;

		// Set up the point and direction of this segment.
		p = new pt(x1, y1);
		pt end = new pt(x2, y2);
		dir = end.subtract(p);
	}

	public String toString() {
		return "s: "+p+" e: "+(p.add(dir));
	}

	public double mag() {
		return dir.mag();
	}

	// Create a line segment from a to b.
	public line (pt a, pt b) {
		p = a;
		dir = b.subtract(a);
	}

	// Returns true iff this segment intersects other.
	public boolean intersect(line other) {

		// lambda*this.dir.x - beta*other.dir.x = other.pt.x - this.pt.x
		// lambda*this.dir.y - beta*other.dir.y = other.pt.y - this.pt.y

		double det = det(this.dir.x, -other.dir.x, this.dir.y, - other.dir.y);

		// Special parallel case.
		if (det == 0) return this.interParallel(other);

		// Get determinants in Cramer's Rule for both parameters lambda and beta (for this and other, respectively).
		double lambdaDet = det(other.p.x-this.p.x, -other.dir.x, other.p.y-this.p.y, - other.dir.y);
		double betaDet = det(this.dir.x, other.p.x-this.p.x, this.dir.y, other.p.y-this.p.y);

		// The segments intersect only if both paramters are in between 0 and 1.
		return lambdaDet/det >= 0 && lambdaDet/det <= 1 && betaDet/det >= 0 && betaDet/det <= 1;
	}

	public boolean interParallel(line other) {

		// Makes this the longer one.
		if (this.mag() < other.mag()) return other.interParallel(this);

		// For there to be an intersection, one of the two points must be on the longer segment.
		return this.contains(other.p) || this.contains(other.p.add(other.dir));
	}

	// Returns true iff myp is contained on this line.
	public boolean contains(pt myp) {

		// First check that the direction is good.
		pt tomyP = myp.subtract(this.p);
		if (Math.abs(dir.crossMag(tomyP)) > 1e-9) return false;

		// Otherwise, we can just do a boundary check on either x or y (whichever has a non-zero delta...)
		if (Math.abs(this.p.x-myp.x) > 1e-9)
			return Math.min(p.x, p.x+dir.x) <= myp.x && myp.x <= Math.max(p.x, p.x+dir.x);
		else
			return Math.min(p.y, p.y+dir.y) <= myp.y && myp.y <= Math.max(p.y, p.y+dir.y);
	}

	public static double det(double a, double b, double c, double d) {
		return a*d - b*c;
	}
}