You have n distinct points on a plane, none of them lie on OY axis. Check that there is a point after removal of which the remaining points are located on one side of the OY axis.

Input

The first line contains a single positive integer n (2 ≤ n ≤ 105).

The following n lines contain coordinates of the points. The i-th of these lines contains two single integers xi and yi (|xi|, |yi| ≤ 109, xi ≠ 0). No two points coincide.

Output

Print "Yes" if there is such a point, "No" — otherwise.

You can print every letter in any case (upper or lower).

Examples

Input

3
1 1
-1 -1
2 -1


Output

Yes

Input

4
1 1
2 2
-1 1
-2 2


Output

No

Input

3
1 2
2 1
4 60


Output

Yes

Note

In the first example the second point can be removed.

In the second example there is no suitable for the condition point.

In the third example any point can be removed.
import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.lang.Math;
import java.math.BigInteger;

public class L {
	long INF = Long.MAX_VALUE / 3;
	int MODULO = 1000 * 1000 * 1000 + 2346;

	class Edge {
		int to;
		long dist;

		Edge(int to, long dist) {
			this.to = to;
			this.dist = dist;
		}
	}

	class Vertex implements Comparable<Vertex> {
		int index;
		long dist;

		Vertex(int index, long dist) {
			this.index = index;
			this.dist = dist;
		}

		@Override
		public int compareTo(Vertex other) {
			// TODO Auto-generated method stub
			return Long.compare(this.dist, other.dist);
		}
	}

	List<Edge>[] graph;
	boolean[] used;
	long maxDist = 0;
	long sum = 0;
	void solve() throws IOException {
		int n = rI();
		int b = 0;
		int m = 0;
		for(int i=0; i<n; ++i){
			int x =  rI();
			int y = rI();
			if(x<0){
				m++;
			}else{
				b++;
			}
		}
		if(b==1||m==1){
			out.println("Yes");
			return;
		}
		if(b==0||m==0){
			out.println("Yes");
			return;
		}
		out.println("No");
	}
	
	class SegmentTree {
		int[] t;

		SegmentTree(int[] a) {
			t = new int[a.length * 4];
			build(a, 1, 1, a.length - 1);
		}

		void build(int[] a, int v, int tl, int tr) {
			if (tr == tl) {
				t[v] = a[tl];
				return;
			}
			int mid = (tr + tl) / 2;
			build(a, 2 * v, tl, mid);
			build(a, 2 * v + 1, mid + 1, tr);
			t[v] = Math.max(t[2 * v], t[2 * v + 1]);
		}

		int getMax(int v, int tl, int tr, int l, int r) {
			if (l > r)
				return (int) -INF;
			if (tr == tl) {
				return t[v];
			}
			if (tl == l && tr == r) {
				return t[v];
			}

			int mid = (tr + tl) / 2;
			int max1 = getMax(2 * v, tl, mid, l, Math.min(r, mid));
			int max2 = getMax(2 * v + 1, mid + 1, tr, Math.max(l, mid + 1), r);
			return Math.max(max1, max2);
		}

		void update(int v, int tl, int tr, int value, int pos) {
			if (tl == tr) {
				t[v] = value;
				return;
			}
			int mid = (tl + tr) / 2;
			if (pos <= mid) {
				update(2 * v, tl, mid, value, pos);
			} else {
				update(2 * v + 1, mid + 1, tr, value, pos);
			}
			t[v] = Math.max(t[2 * v], t[2 * v + 1]);
		}
	}

	int checkBit(int mask, int bit) {
		return (mask >> bit) & 1;
	}

	public static void main(String[] args) throws IOException {

		new L().run();
	}

	boolean isLower(char a) {
		return ((int) a) >= 97 ? true : false;
	}

	int[][] STEPS = { { 0, 1 }, { 1, 0 }, { -1, 0 }, { 0, -1 } };

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;
	Random rnd = new Random();
	static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	L() throws FileNotFoundException {

		try {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		} catch (Exception e) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		}

		tok = new StringTokenizer("");
	}

	long checkBit(long mask, int bit) {
		return (mask >> bit) & 1;
	}

	// ======================================================

	// ======================================================
	void run() throws IOException {
		solve();
		out.close();
	}

	char[] reverseCharArray(char[] arr) {
		char[] ans = new char[arr.length];
		for (int i = 0; i < arr.length; ++i) {
			ans[i] = arr[arr.length - i - 1];
		}
		return ans;
	}

	int sqrt(double m) {
		int l = 0;
		int r = 1000000000 + 9;
		int i = 1000;
		while (r - l > 1) {
			int mid = (r + l) / 2;
			if (mid * mid > m) {
				r = mid;
			} else {
				l = mid;
			}
		}
		return l;
	}

	int countPow(int m, int n) {
		int ans = 0;
		while (m % n == 0 && m > 0) {
			ans++;
			m /= n;
		}
		return ans;
	}

	long binPow(long a, long b, long m) {
		if (b == 0) {
			return 1;
		}
		if (b % 2 == 1) {
			return ((a % m) * (binPow(a, b - 1, m) % m)) % m;
		} else {
			long c = binPow(a, b / 2, m);
			return (c * c) % m;
		}

	}

	int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	long pow(long x, long k) {
		long ans = 1;
		for (int i = 0; i < k; ++i) {
			ans *= x;
		}
		return ans;
	}

	// ////////////////////////////////////////////////////////////////////

	String delimiter = " ";

	String readLine() throws IOException {
		return in.readLine();
	}

	String rS() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine)
				return null;

			tok = new StringTokenizer(nextLine);
		}

		return tok.nextToken(delimiter);
	}

	int rI() throws IOException {
		return Integer.parseInt(rS());
	}

	long rL() throws IOException {
		return Long.parseLong(rS());
	}

	double rD() throws IOException {
		return Double.parseDouble(rS());
	}

	int[] rA(int b) {
		int a[] = new int[b];
		for (int i = 0; i < b; i++) {
			try {
				a[i] = rI();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return a;
	}

	int[] readSortedIntArray(int size) throws IOException {
		Integer[] array = new Integer[size];

		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}

	int[] sortedIntArray(int size, int[] array) throws IOException {
		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}
}