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 \le n \le 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.

Difficulty: VERY_HARD
Tags: Geometry

Starter code:

Solutions:
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
INF = 10 ** 16
n = int(input())
d = {}
a = []
for i in range(n):
	(x, y) = map(int, input().split())
	d[x] = max(d.get(x, -INF), y - x * x)
a = sorted(d.items())
cross = lambda a, b, c: (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
s = []
for p in a:
	while len(s) > 1 and cross(s[-2], s[-1], p) >= 0:
		s.pop()
	s.append(p)
print(len(s) - 1)


n = int(input())
rows = [input().split() for _ in range(n)]
rows = [(int(x), int(y)) for (x, y) in rows]
points = {}
for (x, y) in rows:
	if x in points:
		points[x] = max(y, points[x])
	else:
		points[x] = y
points = sorted(points.items(), key=lambda point: point[0])

def above(p, p1, p2):
	(x, y) = p
	(x1, y1) = p1
	(x2, y2) = p2
	x_2 = x ** 2
	x12 = x1 ** 2
	x22 = x2 ** 2
	x2_x1 = x2 - x1
	eq_b = y2 - y1 - x22 + x12
	term_y = y * x2_x1
	term_x2 = x_2 * x2_x1
	term_x = x * eq_b
	term_c = (y1 - x12) * x2_x1 - x1 * eq_b
	return term_y >= term_x2 + term_x + term_c
Us = []
for (i, p) in enumerate(points):
	while len(Us) >= 2:
		(p1, p2) = Us[-2:]
		if above(p, p1, p2):
			Us.pop()
		else:
			break
	Us.append(p)
out = len(Us) - 1
print(out)


import sys

def cross(o, a, b):
	return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
N = int(input())
A = [None] * N
for i in range(N):
	(x, y) = map(int, sys.stdin.readline().split())
	A[i] = (x, y - x * x)
A.sort()
upper = []
for p in reversed(A):
	while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:
		upper.pop()
	upper.append(p)
while len(upper) >= 2 and upper[-1][0] == upper[-2][0]:
	upper.pop()
print(len(upper) - 1)


import math
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline

def cross(xA, yA, xB, yB):
	return xA * yB - xB * yA

def clockwise(x0, y0, xA, yA, xB, yB):
	return True if cross(xA - x0, yA - y0, xB - x0, yB - y0) < 0 else False
n = int(input())
P = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
	P[i][1] = P[i][1] - P[i][0] ** 2
P = sorted(P, key=lambda x: (x[0], x[1]))
d = {}
for (x, y) in P:
	if x not in d:
		d[x] = y
	d[x] = max(d[x], y)
Q = [[x, y] for (x, y) in d.items()]
S = []
for (x, y) in Q:
	if len(S) > 0 and S[-1][0] == x:
		S.pop()
	while len(S) >= 2 and clockwise(S[-2][0], S[-2][1], S[-1][0], S[-1][1], x, y) == False:
		S.pop()
	S.append([x, y])
print(len(S) - 1)