Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.

Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.

The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.

Input

The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.

The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.

Output

In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).

Examples

Input


3
-1 0
0 2
1 0


Output


2


Input


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


Output


1

Note

On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red. 

<image> The first example.  <image> The second example. 
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

/*

5
0 0
1 0
2 0
3 0
4 0



*/

public class F1143 {
	
	public void solve(Scanner in, PrintWriter out) {
		int n = in.nextInt();
		VecL[] pts = new VecL[n];
		for(int i = 0; i < n; ++i) pts[i] = new VecL(in.nextLong(), in.nextLong());
		for(VecL pt : pts) {
//			System.out.println(pt);
			long x = pt.x;
			long y = pt.y;
			pt.x = x;
			pt.y = y - x * x;
//			System.out.println(pt);
		}
		VecL[] hull = ConvexHull.getHull(pts);
//		System.out.println(Arrays.toString(hull));
		n = hull.length;
		int ans = 0;
		for(int i = 0; i < n - 1; ++i) {
			int j = i + 1;
			if(hull[i].x == hull[j].x) continue;
			while(j < n && hull[j].sub(hull[j - 1]).cross(hull[j - 1].sub(hull[i])) == 0) ++j;
			--j;
			ans++;
//			System.out.println(i + " -> " + Math.max(i, j - 1));
			if(j == n - 1) break;
			i = Math.max(i, j - 1);
		}
		out.println(ans);
	}
	
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		new F1143().solve(in, out);
		in.close();
		out.close();
	}
	
	
	static class ConvexHull {

		static VecL[] upperHull, lowerHull;
		
		public static VecL[] removeDupes(VecL[] points) {
			HashSet<VecL> set=new HashSet<>();
			for (VecL v:points) set.add(v);
			int counter=0;
			points=new VecL[set.size()];
			for (VecL v:set) points[counter++]=v;
			return points;
		}

		//returns the hull in CCW order
		public static VecL[] getHull(VecL[] points) {
			points=points.clone();
			Arrays.sort(points);
			if (points.length<3)
				return upperHull=lowerHull=points;
			int n=points.length, j=2, k=2;
			VecL[] lo=new VecL[n], up=new VecL[n];
			lo[0]=points[0];
			lo[1]=points[1];
			for (int i=2; i<n; i++) {
				VecL p=points[i];
				while (j>1 && !right(lo[j-2], lo[j-1], p)) j--;
				lo[j++]=p;
			}
			up[0]=points[n-1];
			up[1]=points[n-2];
			for (int i=n-3; i>=0; i--) {
				VecL p=points[i];
				while (k>1 && !right(up[k-2], up[k-1], p)) k--;
				up[k++]=p;
			}
			
			VecL[] res=new VecL[j+k-2];
			for (int i=0; i<k; i++) res[i]=up[i];
			for (int i=1; i<j-1; i++) res[k+i-1]=lo[i];
			
			//if you need upper and lower hulls
			upperHull=new VecL[k];
	        for (int i=0; i<k; i++) upperHull[i]=up[k-i-1];
	        lowerHull=new VecL[j];
	        for (int i=0; i<j; i++) lowerHull[i]=lo[i];
			
	        return upperHull;
//			return res;
		}

		//check if a->b->c are in the right order
		static boolean right(VecL a, VecL b, VecL c) {
			return b.sub(a).cross(c.sub(a))>0;
		}

	}
	
	class VecL implements Comparable<VecL> {
		long x, y;
		
		public VecL(long x, long y) {
			this.x=x;
			this.y=y;
		}
		
		public VecL add(VecL o) {
			return new VecL(x+o.x, y+o.y);
		}

		public VecL sub(VecL o) {
			return new VecL(x-o.x, y-o.y);
		}
		
		public VecL scale(long s) {
			return new VecL(x*s, y*s);
		}
		
		public long dot(VecL o) {
			return x*o.x+y*o.y;
		}
		
		public long cross(VecL o) {
			return x*o.y-y*o.x;
		}
		
		public long mag2() {
			return dot(this);
		}
		
		public VecL rot90() {
			return new VecL(-y, x);
		}
		
		public VecL rot270() {
			return new VecL(y, -x);
		}
		
		public String toString() {
			return "("+x+", "+y+")";
		}
		
		public int hashCode() {
			return Long.hashCode(x<<13^(y*57));
		}
		
		public boolean equals(Object oo) {
			VecL o=(VecL)oo;
			return x==o.x&&y==o.y;
		}
		
		public int compareTo(VecL o) {
			if (x!=o.x) return Long.compare(x, o.x);
			return Long.compare(y, o.y);
		}
		
		//origin->q1, axes-> quadrant in ccw direction
		public int quadrant() {
			if (x==0||y==0) {
				if (y==0)
					if (x>=0)
						return 1;
					else
						return 3;
				else
					if (y>=0)
						return 2;
					else
						return 4;
			}
			if (x>0)
				if (y>0)
					return 1;
				else
					return 4;
			else
				if (y>0)
					return 2;
				else
					return 3;
		}
		
		public int radialCompare(VecL o) {
			if (quadrant()==o.quadrant())
				return -Long.signum(cross(o));
			return Integer.compare(quadrant(), o.quadrant());
		}
		
	}
}
