import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Locale;
import java.util.Scanner;
import java.util.regex.Pattern;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

public class Main {

	public static void main(String[] args) throws Exception {
        solve(1);	
    }
     
    public static void solve(int testCases) throws Exception{
    	
    	Line L1 = new Line(new Point(StdIn.readInt(), StdIn.readInt()), new Point(StdIn.readInt(), StdIn.readInt()));
    	Line L2 = new Line(new Point(StdIn.readInt(), StdIn.readInt()), new Point(StdIn.readInt(), StdIn.readInt()));
    	Line L3 = new Line(new Point(StdIn.readInt(), StdIn.readInt()), new Point(StdIn.readInt(), StdIn.readInt()));
    	Line L4 = new Line(new Point(StdIn.readInt(), StdIn.readInt()), new Point(StdIn.readInt(), StdIn.readInt()));
    	int X = 0 , Y = 0;
    	Line[] xL = new Line[2];
    	Line[] yL = new Line[2];
    	int i = 0, j = 0;
    	if(L1.isParallelX()) {X++; if(i < 2){xL[i++] = L1;}}
    	if(L1.isParallelY()) {Y++; if(j < 2){yL[j++] = L1;}}
    	
    	if(L2.isParallelX()) {X++; if(i < 2){xL[i++] = L2;}}
    	if(L2.isParallelY()) {Y++; if(j < 2){yL[j++] = L2;}}
    	
    	if(L3.isParallelX()) {X++; if(i < 2){xL[i++] = L3;}}
    	if(L3.isParallelY()) {Y++; if(j < 2){yL[j++] = L3;}}
    	
    	if(L4.isParallelX()) {X++; if(i < 2){xL[i++] = L4;}}
    	if(L4.isParallelY()) {Y++; if(j < 2){yL[j++] = L4;}}
    	//StdOut.println("X = " + X + " Y = " + Y);
    	//StdOut.println("Distance between lines parallel to X axis = " + xL[0].distance(xL[1]));
    	//StdOut.println("Distance between lines parallel to Y axis = " + yL[0].distance(yL[1]));
    	//StdOut.println(xL[0] + " " + xL[1]);
    	//StdOut.println(yL[0] + " " + yL[1]);
    	if((X != 2 && Y != 2) || (xL[0].distance(xL[1]) <= 0 || yL[0].distance(yL[1]) <= 0) || (xL[0].distance(xL[1]) == yL[0].distance(yL[1]))){
    		StdOut.println("NO");
    		return;
    	}
    	int ymax = Math.max(xL[0].getMaxY(), xL[1].getMaxY());
    	int ymin = Math.min(xL[0].getMinY(), xL[1].getMinY());
    	int xmax = Math.max(xL[0].getMaxX(), xL[1].getMaxX());
    	int xmin = Math.min(xL[0].getMinX(), xL[1].getMinX());
    	//StdOut.println("xmin = " + xmin + " xmax = " + xmax + " ymin = " + ymin + " ymax = " + ymax);
    	for(int k = 0 ; k < 2 ; k++){
    		int x = yL[k].getFirstX();
    		int y1 = yL[k].getFirstY();
    		int y2 = yL[k].getSecondY();
    		if(y2 > y1){
    			int temp = y1;
    			y1 = y2;
    			y2 = temp;
    		}
    		//StdOut.println("x = " + x + " y1 = " + y1 + " y2 = " + y2);
    		if((x < xmin || x > xmax) || (y1 < ymax || y2 > ymin)){
    			StdOut.println("NO");
    			return;
    		}
    	}
    	StdOut.println("YES");
    }      


}

class Point{
	private int x;
	private int y;
	
	public Point(int x, int y){
		this.x = x;
		this.y = y;
	}
	
	public int X(){
		return x;
	}
	
	public int Y(){
		return y;
	}
	
	public String toString(){
		return "("+x+","+y+")";
	}
}

class Line{
	private Point p1;
	private Point p2;
	
	public Line(Point P, Point Q){
		this.p1 = P;
		this.p2 = Q;
	}
	
	public boolean isParallelX(){
		return p1.Y() == p2.Y();
	}
	
	public boolean isParallelY(){
		return p1.X() == p2.X();
	}
	
	public int distance(Line that){
		if(isParallelX()){
			return Math.abs(this.p1.X() - that.p1.X());
		}
		return Math.abs(this.p1.Y() - that.p1.Y());
	}
	
	public int getFirstX(){
		return p1.X();
	}
	
	public int getSecondX(){
		return p2.X();
	}
	
	public int getFirstY(){
		return p1.Y();
	}
	
	public int getSecondY(){
		return p2.Y();
	}
	
	public int getMinX(){
		if(p1.X() < p2.X())
			return p1.X();
		return p2.X();
	}
	
	public int getMaxX(){
		if(p1.X() > p2.X())
			return p1.X();
		return p2.X();
	}
	
	public int getMinY(){
		if(p1.Y() < p2.Y())
			return p1.Y();
		return p2.Y();
	}
	
	public int getMaxY(){
		if(p1.Y() > p2.Y())
			return p1.Y();
		return p2.Y();
	}
	
	public String toString(){
		return p1 + "->" + p2;
	}
}

final class StdIn {
 
    private StdIn() { }
 
    private static Scanner scanner;
    
    private static final String CHARSET_NAME = "UTF-8";
 
    private static final Locale LOCALE = Locale.US;
 
    private static final Pattern WHITESPACE_PATTERN = Pattern.compile("\\p{javaWhitespace}+");
 
    private static final Pattern EMPTY_PATTERN = Pattern.compile("");
 
    private static final Pattern EVERYTHING_PATTERN = Pattern.compile("\\A");
 
    public static boolean isEmpty() {
        return !scanner.hasNext();
    }
 
    public static boolean hasNextLine() {
        return scanner.hasNextLine();
    }
 
    public static boolean hasNextChar() {
        scanner.useDelimiter(EMPTY_PATTERN);
        boolean result = scanner.hasNext();
        scanner.useDelimiter(WHITESPACE_PATTERN);
        return result;
    }
 
    public static String readLine() {
        String line;
        try                 { line = scanner.nextLine(); }
        catch (Exception e) { line = null;               }
        return line;
    }
 
    public static char readChar() {
        scanner.useDelimiter(EMPTY_PATTERN);
        String ch = scanner.next();
        assert (ch.length() == 1) : "Internal (Std)In.readChar() error!"
            + " Please contact the authors.";
        scanner.useDelimiter(WHITESPACE_PATTERN);
        return ch.charAt(0);
    }  
 
 
    public static String readAll() {
        if (!scanner.hasNextLine())
            return "";
 
        String result = scanner.useDelimiter(EVERYTHING_PATTERN).next();
        // not that important to reset delimeter, since now scanner is empty
        scanner.useDelimiter(WHITESPACE_PATTERN); // but let's do it anyway
        return result;
    }
 
    public static String readString() {
        return scanner.next();
    }
 
    public static int readInt() {
        return scanner.nextInt();
    }
 
    public static double readDouble() {
        return scanner.nextDouble();
    }
 
    public static float readFloat() {
        return scanner.nextFloat();
    }
 
    public static long readLong() {
        return scanner.nextLong();
    }
    
    public static short readShort() {
        return scanner.nextShort();
    }
 
    public static byte readByte() {
        return scanner.nextByte();
    }
 
    public static boolean readBoolean() {
        String s = readString();
        if (s.equalsIgnoreCase("true"))  return true;
        if (s.equalsIgnoreCase("false")) return false;
        if (s.equals("1"))               return true;
        if (s.equals("0"))               return false;
        throw new InputMismatchException();
    }
 
    public static String[] readAllStrings() {
        // we could use readAll.trim().split(), but that's not consistent
        // because trim() uses characters 0x00..0x20 as whitespace
        String[] tokens = WHITESPACE_PATTERN.split(readAll());
        if (tokens.length == 0 || tokens[0].length() > 0)
            return tokens;
 
        // don't include first token if it is leading whitespace
        String[] decapitokens = new String[tokens.length-1];
        for (int i = 0; i < tokens.length - 1; i++)
            decapitokens[i] = tokens[i+1];
        return decapitokens;
    }
 
    public static String[] readAllLines() {
        ArrayList<String> lines = new ArrayList<String>();
        while (hasNextLine()) {
            lines.add(readLine());
        }
        return lines.toArray(new String[0]);
    }
 
    public static int[] readAllInts() {
        String[] fields = readAllStrings();
        int[] vals = new int[fields.length];
        for (int i = 0; i < fields.length; i++)
            vals[i] = Integer.parseInt(fields[i]);
        return vals;
    }
 
    public static double[] readAllDoubles() {
        String[] fields = readAllStrings();
        double[] vals = new double[fields.length];
        for (int i = 0; i < fields.length; i++)
            vals[i] = Double.parseDouble(fields[i]);
        return vals;
    }
    
    static {
        resync();
    }
 
    private static void resync() {
        setScanner(new Scanner(new java.io.BufferedInputStream(System.in), CHARSET_NAME));
    }
    
    private static void setScanner(Scanner scanner) {
        StdIn.scanner = scanner;
        StdIn.scanner.useLocale(LOCALE);
    }
 
    public static int[] readInts() {
        return readAllInts();
    }
 
    public static double[] readDoubles() {
        return readAllDoubles();
    }
 
    public static String[] readStrings() {
        return readAllStrings();
    }
 
}
 
final class StdOut {
 
    private static final String CHARSET_NAME = "UTF-8";
 
    private static final Locale LOCALE = Locale.US;
 
    private static PrintWriter out;
 
    static {
        try {
            out = new PrintWriter(new OutputStreamWriter(System.out, CHARSET_NAME), true);
        }
        catch (UnsupportedEncodingException e) { System.out.println(e); }
    }
 
    private StdOut() { }
 
    public static void close() {
        out.close();
    }
 
    public static void println() {
        out.println();
    }
 
    public static void println(Object x) {
        out.println(x);
    }
 
    public static void println(boolean x) {
        out.println(x);
    }
 
    public static void println(char x) {
        out.println(x);
    }
 
    public static void println(double x) {
        out.println(x);
    }
 
    public static void println(float x) {
        out.println(x);
    }
 
    public static void println(int x) {
        out.println(x);
    }
 
    public static void println(long x) {
        out.println(x);
    }
 
    public static void println(short x) {
        out.println(x);
    }
 
    public static void println(byte x) {
        out.println(x);
    }
 
    public static void print() {
        out.flush();
    }
 
    public static void print(Object x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(boolean x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(char x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(double x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(float x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(int x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(long x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(short x) {
        out.print(x);
        out.flush();
    }
 
    public static void print(byte x) {
        out.print(x);
        out.flush();
    }
 
    public static void printf(String format, Object... args) {
        out.printf(LOCALE, format, args);
        out.flush();
    }
 
    public static void printf(Locale locale, String format, Object... args) {
        out.printf(locale, format, args);
        out.flush();
    }
 
} 