You are given n points on Cartesian plane. Every point is a lattice point (i. e. both of its coordinates are integers), and all points are distinct.

You may draw two straight lines (not necessarily distinct). Is it possible to do this in such a way that every point lies on at least one of these lines?

Input

The first line contains one integer n (1 ≤ n ≤ 105) — the number of points you are given.

Then n lines follow, each line containing two integers xi and yi (|xi|, |yi| ≤ 109)— coordinates of i-th point. All n points are distinct.

Output

If it is possible to draw two straight lines in such a way that each of given points belongs to at least one of these lines, print YES. Otherwise, print NO.

Examples

Input

5
0 0
0 1
1 1
1 -1
2 2


Output

YES


Input

5
0 0
1 0
2 1
1 1
2 3


Output

NO

Note

In the first example it is possible to draw two lines, the one containing the points 1, 3 and 5, and another one containing two remaining points.

<image>
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;
import java.util.Map.Entry;

public class Main
{
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
	private PrintWriter pw;
	private long mod = 1000000000
			+ 7;

	private StringBuilder ans_sb;
	private long sum = 0;
	private int cnt;

	private void soln()
	{
		int n = nextInt();
		Pair[] arr = new Pair[n];
		for (int i = 0; i < n; i++)
			arr[i] = new Pair(
					nextInt(),
					nextInt());
		if (n <= 4)
		{
			pw.println(
					"YES");
		} else
		{
			ArrayList<Integer> l = new ArrayList<>();
			boolean f = false;
			for (int i = 2; i < n; i++)
			{
				long y2 = arr[1].y;
				long x2 = arr[1].x;
				long x1 = arr[0].x;
				long y1 = arr[0].y;
				long v = (y2
						- y1)
						* arr[i].x
						+ (x1 - x2)
								* arr[i].y
						- x1 * (y2
								- y1)
						+ y1 * (x2
								- x1);
				if (v != 0)
					l.add(i);
			}
			if (l.size() <= 2)
			{
				f = true;
			} else
			{
				// debug(l.size());
				int i1 = l
						.get(0);
				int i2 = l
						.get(1);
				boolean ff = true;
				for (int i = 2; i < l
						.size(); i++)
				{
					long y2 = arr[i1].y;
					long x2 = arr[i1].x;
					long x1 = arr[i2].x;
					long y1 = arr[i2].y;
					int i3 = l
							.get(i);
					long v = (y2
							- y1)
							* arr[i3].x
							+ (x1 - x2)
									* arr[i3].y
							- x1 * (y2
									- y1)
							+ y1 * (x2
									- x1);
					if (v != 0)
					{
						ff = false;
						break;
					}
					// debug(ff);
				}
				f |= ff;
			}
			if (!f)
			{
				l.clear();
				for (int i = 0; i < n; i++)
				{
					if (i == 1
							|| i == 2)
						continue;
					long y2 = arr[1].y;
					long x2 = arr[1].x;
					long x1 = arr[2].x;
					long y1 = arr[2].y;
					long v = (y2
							- y1)
							* arr[i].x
							+ (x1 - x2)
									* arr[i].y
							- x1 * (y2
									- y1)
							+ y1 * (x2
									- x1);
					if (v != 0)
						l.add(i);
				}
				if (l.size() <= 2)
				{
					f = true;
				} else
				{
					int i1 = l
							.get(0);
					int i2 = l
							.get(1);
					boolean ff = true;
					for (int i = 2; i < l
							.size(); i++)
					{
						long y2 = arr[i1].y;
						long x2 = arr[i1].x;
						long x1 = arr[i2].x;
						long y1 = arr[i2].y;
						int i3 = l
								.get(i);
						long v = (y2
								- y1)
								* arr[i3].x
								+ (x1 - x2)
										* arr[i3].y
								- x1 * (y2
										- y1)
								+ y1 * (x2
										- x1);
						if (v != 0)
						{
							ff = false;
							break;
						}
					}
					f |= ff;
				}
				if (!f)
				{
					l.clear();
					for (int i = 0; i < n; i++)
					{
						if (i == 0
								|| i == 2)
							continue;
						long y2 = arr[0].y;
						long x2 = arr[0].x;
						long x1 = arr[2].x;
						long y1 = arr[2].y;
						long v = (y2
								- y1)
								* arr[i].x
								+ (x1 - x2)
										* arr[i].y
								- x1 * (y2
										- y1)
								+ y1 * (x2
										- x1);
						if (v != 0)
							l.add(i);
					}
					if (l.size() <= 2)
					{
						f = true;
					} else
					{
						int i1 = l
								.get(0);
						int i2 = l
								.get(1);
						boolean ff = true;
						for (int i = 2; i < l
								.size(); i++)
						{
							long y2 = arr[i1].y;
							long x2 = arr[i1].x;
							long x1 = arr[i2].x;
							long y1 = arr[i2].y;
							int i3 = l
									.get(i);
							long v = (y2
									- y1)
									* arr[i3].x
									+ (x1 - x2)
											* arr[i3].y
									- x1 * (y2
											- y1)
									+ y1 * (x2
											- x1);
							if (v != 0)
							{
								ff = false;
								break;
							}
						}
						f |= ff;
					}
				}
			}
			if (f)
				pw.println(
						"YES");
			else
				pw.println(
						"NO");
		}
	}

	private class Pair
	{
		long x, y;

		public Pair(
				int a,
				int b)
		{
			x = a;
			y = b;
		}
	}

	class BitsetLong
	{

		static final int LOG = 6;
		static final int SIZE = 1 << LOG;
		static final int MASK = SIZE
				- 1;

		private long[] data;

		public BitsetLong(
				int n)
		{
			data = new long[(n >> LOG)
					+ 2];
		}

		void set(
				int i)
		{
			data[i >> LOG] |= 1L << (i
					& MASK);
		}

		void unset(
				int i)
		{
			data[i >> LOG] &= ~(1L << (i
					& MASK));
		}

		void flip(
				int i)
		{
			data[i >> LOG] ^= 1L << (i
					& MASK);
		}

		int get(int i)
		{
			return (int) ((data[i >> LOG] >>> (i
					& MASK))
					& 1);
		}

		void print()
		{
			for (int i = 0; i < data.length; i++)
			{
				System.out
						.print(Long
								.toString(
										data[i],
										2));
			}
			System.out
					.println();
		}

		long getWord(
				int i)
		{
			if (i <= -SIZE
					|| (i >> LOG)
							+ 1 >= data.length)
			{
				return 0;
			}
			int rem = i
					& MASK;
			int idx = i >> LOG;

			if (rem == 0)
			{
				return data[idx];
			}

			long head = idx < 0
					? 0
					: (data[idx] >>> rem);
			long tail = data[idx
					+ 1] << (SIZE
							- rem);

			return head
					| tail;
		}
	}

	int count(
			long[] bs,
			int len)
	{
		int ret = 0;
		for (int i = 0; i << 6 < len; i++)
		{
			if (((i + 1) << 6) <= len)
			{
				ret += Long
						.bitCount(
								bs[i]);
			} else
			{
				int rem = len
						& 63;
				ret += Long
						.bitCount(
								bs[i] << (64
										- rem));
			}
		}
		return ret;
	}

	private String solveEqn(
			long a,
			long b)
	{
		long x = 0,
				y = 1,
				lastx = 1,
				lasty = 0,
				temp;
		while (b != 0)
		{
			long q = a
					/ b;
			long r = a
					% b;
			a = b;
			b = r;
			temp = x;
			x = lastx
					- q * x;
			lastx = temp;
			temp = y;
			y = lasty
					- q * y;
			lasty = temp;
		}
		return lastx
				+ " "
				+ lasty;
	}

	private void debug(
			Object... o)
	{
		System.out
				.println(
						Arrays.deepToString(
								o));
	}

	private long pow(
			long a,
			long b,
			long c)
	{
		if (b == 0)
			return 1;
		long p = pow(
				a,
				b / 2,
				c);
		p = (p * p)
				% c;
		return (b
				% 2 == 0)
						? p
						: (a * p)
								% c;
	}

	private long gcd(
			long n,
			long l)
	{
		if (l == 0)
			return n;
		return gcd(
				l,
				n % l);
	}

	public static void main(
			String[] args)
			throws Exception
	{
		new Thread(
				null,
				new Runnable()
				{
					@Override
					public void run()
					{
						new Main()
								.solve();
					}
				},
				"1",
				1 << 26).start();
		// new Main().solve();
	}

	public StringBuilder solve()
	{
		InputReader(
				System.in);
		/*
		 * try { InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
		 * } catch(FileNotFoundException e) {}
		 */
		pw = new PrintWriter(
				System.out);
		// ans_sb = new StringBuilder();
		soln();

		pw.close();
		// System.out.println(ans_sb);
		return ans_sb;
	}

	public void InputReader(
			InputStream stream1)
	{
		stream = stream1;
	}

	private boolean isWhitespace(
			int c)
	{
		return c == ' '
				|| c == '\n'
				|| c == '\r'
				|| c == '\t'
				|| c == -1;
	}

	private boolean isEndOfLine(
			int c)
	{
		return c == '\n'
				|| c == '\r'
				|| c == -1;
	}

	private int read()
	{
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars)
		{
			curChar = 0;
			try
			{
				numChars = stream
						.read(buf);
			} catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	private int nextInt()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		int sgn = 1;
		if (c == '-')
		{
			sgn = -1;
			c = read();
		}
		int res = 0;
		do
		{
			if (c < '0'
					|| c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(
				c));
		return res
				* sgn;
	}

	private long nextLong()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		int sgn = 1;
		if (c == '-')
		{
			sgn = -1;
			c = read();
		}
		long res = 0;
		do
		{
			if (c < '0'
					|| c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(
				c));
		return res
				* sgn;
	}

	private String nextToken()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(
					c);
			c = read();
		} while (!isSpaceChar(
				c));
		return res
				.toString();
	}

	private String nextLine()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(
					c);
			c = read();
		} while (!isEndOfLine(
				c));
		return res
				.toString();
	}

	private int[] nextIntArray(
			int n)
	{
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
		{
			arr[i] = nextInt();
		}
		return arr;
	}

	private long[] nextLongArray(
			int n)
	{
		long[] arr = new long[n];
		for (int i = 0; i < n; i++)
		{
			arr[i] = nextLong();
		}
		return arr;
	}

	private void pArray(
			int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out
					.print(arr[i]
							+ " ");
		}
		System.out
				.println();
		return;
	}

	private void pArray(
			long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out
					.print(arr[i]
							+ " ");
		}
		System.out
				.println();
		return;
	}

	private boolean isSpaceChar(
			int c)
	{
		if (filter != null)
			return filter
					.isSpaceChar(
							c);
		return isWhitespace(
				c);
	}

	private char nextChar()
	{
		int c = read();
		while (isSpaceChar(
				c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(
				c))
			c = read();
		return c1;
	}

	private interface SpaceCharFilter
	{
		public boolean isSpaceChar(
				int ch);
	}
}