import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;

public class Validate {
	final int MAXN = 100000;
	final long MAXL = 1000000000L * 1000000000L;


	public void run() {
		StrictScanner inf = new StrictScanner(System.in);
		int n = inf.nextInt();
		long l = inf.nextLong();
		int k = inf.nextInt();
		inf.nextLine();
		ensureLimits(n, 3, MAXN, "N is incorrect");
		ensureLimits(l, 0, MAXL, "L is incorrect");
		ensureLimits(k, 0, n / 2, "K is incorrect");
		int[] a = new int[k];
		for (int i = 0; i < k; i++) {
			a[i] = inf.nextInt();
			ensureLimits(a[i], 1, n, "a[" + (i + 1) + "] is bad");
		}
		inf.nextLine();
		for (int i = 1; i < k; i++) {
			ensure((a[i] - 1) > a[i-1], "2 line not sorted, or a[i] + 1 == a[i+1]");
		}
		Point[] copy = new Point[n], p = new Point[n];
		for (int i = 0; i < n; i++) {
			p[i] = new Point(inf.nextLong(), inf.nextLong());
			inf.nextLine();

			ensureLimits((long) p[i].x, -1000000000000000000L, 1000000000000000000L, (i+2) + " line is incorrect");
			ensureLimits((long) p[i].y, -1000000000000000000L, 1000000000000000000L, (i+2) + " line is incorrect");
			copy[i] = new Point(p[i].x, p[i].y);
		}
		Point[] convex = convexHull(copy);
		ensure(convex.length == n, "It is not convex!!!");
		int start = -1;
		for (int i = 0; i < n; i++) {
			if (convex[i].compareTo(p[0]) == 0) start = i;
		}
			
		boolean f = true;
		for (int i = 1; i < n; i++) {
			if (p[i].compareTo( convex[(start + n - i) % n]) != 0) f = false;
		}
		if (!f) {
                    for (int i = 1; i < n; i++) {
	   		ensure(p[i].compareTo( convex[(start + i) % n]) == 0, "Not in order");
		    }
		}
		inf.close();
	}

	public static void main(String[] args) {
		new Validate().run();
	}

	public class StrictScanner {
		private final BufferedReader in;
		private String line = "";
		private int pos;
		private int lineNo;

		public StrictScanner(InputStream source) {
			in = new BufferedReader(new InputStreamReader(source));
			nextLine();
		}

		public void close() {
			ensure(line == null, "Extra data at the end of file");
			try {
				in.close();
			} catch (IOException e) {
				throw new AssertionError("Failed to close with " + e);
			}
		}

		public void nextLine() {
			ensure(line != null, "EOF");
			ensure(pos == line.length(), "Extra characters on line " + lineNo);
			try {
/*ADD TRIM, DELETE HIM!!!*/		line = in.readLine();
			} catch (IOException e) {
				throw new AssertionError("Failed to read line with " + e);
			}
			pos = 0;
			lineNo++;
		}

		public String next() {
			ensure(line != null, "EOF");
			ensure(line.length() > 0, "Empty line " + lineNo);
			if (pos == 0)
				ensure(line.charAt(0) > ' ', "Line " + lineNo
						+ " starts with whitespace");
			else {
				ensure(pos < line.length(), "Line " + lineNo + " is over");
				ensure(line.charAt(pos) == ' ', "Wrong whitespace on line "
						+ lineNo);
				pos++;
				ensure(pos < line.length(), "Line " + lineNo + " is over");
				ensure(line.charAt(0) > ' ', "Line " + lineNo
						+ " has double whitespace");
			}
			StringBuilder sb = new StringBuilder();
			while (pos < line.length() && line.charAt(pos) > ' ')
				sb.append(line.charAt(pos++));
			return sb.toString();
		}

		public int nextInt() {
			String s = next();
			ensure(s.length() == 1 || s.charAt(0) != '0',
					"Extra leading zero in number " + s + " on line " + lineNo);
			ensure(s.charAt(0) != '+', "Extra leading '+' in number " + s
					+ " on line " + lineNo);
			try {
				return Integer.parseInt(s);
			} catch (NumberFormatException e) {
				throw new AssertionError("Malformed number " + s + " on line "
						+ lineNo);
			}
		}

		public long nextLong() {
			String s = next();
			ensure(s.length() == 1 || s.charAt(0) != '0',
					"Extra leading zero in number " + s + " on line " + lineNo);
			ensure(s.charAt(0) != '+', "Extra leading '+' in number " + s
					+ " on line " + lineNo);
			try {
				return Long.parseLong(s);
			} catch (NumberFormatException e) {
				throw new AssertionError("Malformed number " + s + " on line "
						+ lineNo);
			}
		}


		public double nextDouble() {
			String s = next();
			ensure(s.length() == 1 || s.startsWith("0.") || s.charAt(0) != '0',
					"Extra leading zero in number " + s + " on line " + lineNo);
			ensure(s.charAt(0) != '+', "Extra leading '+' in number " + s
					+ " on line " + lineNo);
			try {
				return Double.parseDouble(s);
			} catch (NumberFormatException e) {
				throw new AssertionError("Malformed number " + s + " on line "
						+ lineNo);
			}
		}
	}

	void ensure(boolean b, String message) {
		if (!b) {
			throw new AssertionError(message);
		}
	}
	void ensureLimits(long n, long from, long to, String name) {
		ensure(from <= n && n <= to, name + " must be from " + from + " to "
				+ to);
	}


	void ensureLimits(int n, int from, int to, String name) {
		ensure(from <= n && n <= to, name + " must be from " + from + " to "
				+ to);
	}

	static final double eps = 1e-9;

	  public static int sign(double a) {
	    return Math.abs(a) < eps ? 0 : a < 0 ? -1 : 1;
	  }

	  public static double sqr(double x) {
	    return x * x;
	  }

	  public static double quickHypot(double x, double y) {
	    return Math.sqrt(x * x + y * y);
	  }

	  public static class Point implements Comparable<Point> {
	    double x, y;

	    public Point(double x, double y) {
	      this.x = x;
	      this.y = y;
	    }

	    public Point sub(Point b) {
	      return new Point(x - b.x, y - b.y);
	    }

	    public double cross(Point b) {
	      return x * b.y - y * b.x;
	    }

	    public double dot(Point b) {
	      return x * b.x + y * b.y;
	    }

	    public int compareTo(Point o) {
	      int comp = sign(x - o.x);
	      if (comp != 0)
	        return comp;
	      return sign(y - o.y);
	    }
	  }

	  public static class Line {
	    double a, b, c;

	    void norm() {
	      double d = Math.sqrt(a * a + b * b);
	      a /= d;
	      b /= d;
	      c /= d;
	      if (a < -eps || a < eps && b < 0) {
	        a = -a;
	        b = -b;
	        c = -c;
	      }
	    }

	    public Line(double a, double b, double c) {
	      this.a = a;
	      this.b = b;
	      this.c = c;
	      norm();
	    }

	    public Line(Point p1, Point p2) {
	      a = +(p1.y - p2.y);
	      b = -(p1.x - p2.x);
	      c = p1.x * p2.y - p2.x * p1.y;
	      norm();
	    }

	    public boolean parallel(Line line) {
	      return sign(det(a, b, line.a, line.b)) == 0;
	    }

	    public boolean equivalent(Line line) {
	      return sign(det(a, b, line.a, line.b)) == 0 && sign(det(a, c, line.a, line.c)) == 0
	          && sign(det(b, c, line.b, line.c)) == 0;
	    }

	    public double angle() {
	      return Math.atan2(-a, b);
	    }
	  }

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

	  public static double angle(Point a, Point p, Point b) {
	    a = a.sub(p);
	    b = b.sub(p);
	    return Math.atan2(a.cross(b), a.dot(b));
	  }

	  public static double cross(Point a, Point b, Point c) {
	    return b.sub(a).cross(c.sub(a));
	  }

	  public static int crossop(Point a, Point b, Point c) {
	    return sign(cross(a, b, c));
	  }

	  public static boolean cw(Point a, Point b, Point c) {
	    return crossop(a, b, c) < 0;
	  }

	  public static boolean ccw(Point a, Point b, Point c) {
	    return crossop(a, b, c) > 0;
	  }

	  public static boolean isMiddle(double a, double m, double b) {
	    return Math.abs(m - a) < eps || Math.abs(m - b) < eps || (a < m) != (b < m);
	  }

	  public static boolean isMiddle(Point a, Point m, Point b) {
	    return crossop(a, m, b) == 0 && isMiddle(a.x, m.x, b.x) && isMiddle(a.y, m.y, b.y);
	  }

	  public static boolean isTouchIntersect(Point a, Point b, Point c, Point d) {
	    return isMiddle(a, c, b) || isMiddle(a, d, b) || isMiddle(c, a, d) || isMiddle(c, b, d);
	  }

	  public static boolean isCrossIntersect(Point a, Point b, Point c, Point d) {
	    return crossop(a, b, c) * crossop(a, b, d) < 0 && crossop(c, d, a) * crossop(c, d, b) < 0;
	  }

	  public static boolean isIntersect(Point a, Point b, Point c, Point d) {
	    return isCrossIntersect(a, b, c, d) || isTouchIntersect(a, b, c, d);
	  }

	  static boolean isIntersect2(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
	    if (Math.max(x1, x2) < Math.min(x3, x4) - eps || Math.max(x3, x4) < Math.min(x1, x2) - eps
	        || Math.max(y1, y2) < Math.min(y3, y4) - eps || Math.max(y3, y4) < Math.min(y1, y2) - eps) {
	      return false;
	    }
	    double z1 = (x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1);
	    double z2 = (x4 - x1) * (y2 - y1) - (y4 - y1) * (x2 - x1);
	    if (z1 < -eps && z2 < -eps || z1 > eps && z2 > eps) {
	      return false;
	    }
	    double z3 = (x1 - x3) * (y4 - y3) - (y1 - y3) * (x4 - x3);
	    double z4 = (x2 - x3) * (y4 - y3) - (y2 - y3) * (x4 - x3);
	    if (z3 < -eps && z4 < -eps || z3 > eps && z4 > eps) {
	      return false;
	    }
	    return true;
	  }

	  public static double signedArea(double[] x, double[] y) {
	    int n = x.length;
	    double s = 0;
	    for (int i = 0; i < n; i++) {
	      s += (x[(i + 1) % n] - x[i]) * (y[(i + 1) % n] + y[i]);
	    }
	    return s;
	  }

	  public static Point getIntersection(Point p1, Point p2, Point q1, Point q2) {
	    return getIntersection(new Line(p1, p2), new Line(q1, q2));
	  }

	  public static Point getIntersection(Line A, Line B) {
	    double a1 = A.a;
	    double b1 = A.b;
	    double c1 = A.c;
	    double a2 = B.a;
	    double b2 = B.b;
	    double c2 = B.c;
	    double det = a1 * b2 - a2 * b1;
	    if (sign(det) == 0) {
	      return null;
	    }
	    double x = -(c1 * b2 - c2 * b1) / det;
	    double y = -(a1 * c2 - a2 * c1) / det;
	    return new Point(x, y);
	  }

	  public static double pointToLineDistance(Point p, Line line) {
	    return Math.abs(line.a * p.x + line.b * p.y + line.c) / quickHypot(line.a, line.b);
	  }

	  public static double pointToSegmentDistance(Point p, Point a, Point b) {
	    double dx = b.x - a.x;
	    double dy = b.y - a.y;
	    double px = p.x - a.x;
	    double py = p.y - a.y;
	    double squaredLength = dx * dx + dy * dy;
	    double proj = dx * px + dy * py;
	    if (proj < 0 || squaredLength < eps * eps) {
	      return quickHypot(px, py);
	    }
	    if (proj > squaredLength) {
	      return quickHypot(px - dx, py - dy);
	    }
	    return quickHypot(px - (double) proj / squaredLength * dx, py - (double) proj / squaredLength * dy);
	  }

	  public static double pointToSegmentDistance2(Point p, Point a, Point b) {
	    double s12 = sqr(a.x - b.x) + sqr(a.y - b.y);
	    double s1 = sqr(p.x - a.x) + sqr(p.y - a.y);
	    double s2 = sqr(p.x - b.x) + sqr(p.y - b.y);
	    if (s12 > eps && Math.abs(s1 - s2) <= s12)
	      return Math.abs(cross(p, a, b)) / Math.sqrt(s12);
	    else
	      return Math.sqrt(Math.min(s1, s2));
	  }

	  public static Point[] convexHull(Point[] p) {
	    int n = p.length;
	    if (n <= 1)
	      return p;
	    int k = 0;
	    Arrays.sort(p);
	    Point[] q = new Point[n * 2];
	    for (int i = 0; i < n; q[k++] = p[i++])
	      for (; k > 1 && !cw(q[k - 2], q[k - 1], p[i]); --k)
	        ;
	    for (int i = n - 2, t = k; i >= 0; q[k++] = p[i--])
	      for (; k > t && !cw(q[k - 2], q[k - 1], p[i]); --k)
	        ;
	    Point[] res = new Point[k - 1 - (q[0].compareTo(q[1]) == 0 ? 1 : 0)];
	    System.arraycopy(q, 0, res, 0, res.length);
	    return res;
	  }



}