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.lang.*;
import java.math.*;
import java.util.*;
import java.io.*;

public class Main {
    void solve() {
        int n=ni();
        Point p []=new Point[n];
        for(int i=0;i<n;i++) {
            int x = ni(), y = ni();
            p[i] = new Point(x, y - x * 1L * x);
        }
        Polygon.findConvexHull(p);
        int ans=0;
        for(int i=1;i<upper.length;i++) {
            if(upper[i-1].x!=upper[i].x) ans++;
        }
        pw.println(ans);

    }
    static Point lower[];
   static Point upper[];
    static class Polygon {
        Point[] g;

        Polygon(Point[] o) {
            g = o;
        }

        static void findConvexHull(Point[] points) {
            int n = points.length;
            Arrays.sort(points);
            lower = new Point[2 * n];
            upper = new Point[2 * n];
            int k = 0, start = 0;
            for (int i = 0; i < n; i++) {
                Point p = points[i];
                while (k - start >= 2 && p.minus(lower[k - 1]).cross(p.minus(lower[k - 2])) >= 0)
                    k--;
                lower[k++] = p;
            }
            lower = Arrays.copyOf(lower, k);
            start = 0;
            k = 0;
            for (int i = n - 1; i >= 0; i--) {
                Point p = points[i];
                while (k - start >= 2 && p.minus(upper[k - 1]).cross(p.minus(upper[k - 2])) >= 0)
                    k--;
                upper[k++] = p;
            }
            upper = Arrays.copyOf(upper, k);
        }
    }
    static public class Point implements Comparable<Point> {

        double x, y;

        public Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        public int compareTo(Point o) {
            if (x != o.x)
                return Double.compare(x, o.x);
            return Double.compare(y, o.y);
        }

        public double dot(Point o) {
            return x * 1L * o.x + y * 1L * o.y;
        }

        public double cross(Point o) {
            return x * 1L * o.y - y * 1L * o.x;
        }

        public Point minus(Point p) {
            return new Point(x - p.x, y - p.y);
        }

        // slope of a-c > a-b
        public static double ccw(Point a, Point b, Point c) {
            return (c.y - a.y) * 1L * (b.x - a.x) - (b.y - a.y) * 1L * (c.x - a.x);
        }

        @Override
        public String toString() {
            return "[" + x + ", " + y + "]";
        }

        public double dist(Point o) {
            double X = x - o.x;
            double Y = y - o.y;
            return Math.sqrt(X * X + Y * Y);
        }
    }

    static public class Line {
        public double a, b, c;
        public static final double EPS = 1e-9;

        public Line(double a, double b, double c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        public Line(double m, double c) {
            new Line(m, -1.0, c);
        }

        public Line(Point p1, Point p2) {
            a = +(p1.y - p2.y);
            b = -(p1.x - p2.x);
            c = p1.x * p2.y - p2.x * p1.y;
        }

        public boolean isParallel(Line line) {
            return (a * line.b - b * line.a) < EPS;
        }

        public boolean isPerpendicular(Line line) {
            return sign(a * line.a + b * line.b) == 0;
        }

        public Point intersect(Line line) {
            double d = a * line.b - line.a * b;
            if (sign(d) == 0)
                return null;
            double x = -(c * line.b - line.c * b) / d;
            double y = -(a * line.c - line.a * c) / d;
            return new Point(x, y);
        }

        public Point dist(Point a) {
            double m = -1 / slope();
            double c = a.y - m * a.x;
            return intersect(new Line(m, c));
        }

        public double slope() {
            return sign(-a / b) == 0 ? 0 : (-a / b);
        }

        public static int sign(double a) {
            return a < -EPS ? -1 : a > EPS ? 1 : 0;
        }
    }
    long M = (long)1e9+7;
    InputStream is;
    PrintWriter pw;
    String INPUT = "";

    void run() throws Exception {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        pw = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        pw.flush();
        if (!INPUT.isEmpty()) tr(System.currentTimeMillis() - s + "ms");

    }

    public static void main(String[] args) throws Exception {
        new Main().run();
    }

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if (lenbuf == -1) throw new InputMismatchException();
        if (ptrbuf >= lenbuf) {
            ptrbuf = 0;
            try {
                lenbuf = is.read(inbuf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (lenbuf <= 0) return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) {
        return !(c >= 33 && c <= 126);
    }

    private int skip() {
        int b;
        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
        return b;
    }

    private double nd() {
        return Double.parseDouble(ns());
    }

    private char nc() {
        return (char) skip();
    }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while (p < n && !(isSpaceChar(b))) {
            buf[p++] = (char) b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for (int i = 0; i < n; i++) map[i] = ns(m);
        return map;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = ni();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
        if (b == '-') {
            minus = true;
            b = readByte();
        }

        while (true) {
            if (b >= '0' && b <= '9') {
                num = num * 10 + (b - '0');
            } else {
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
        if (b == '-') {
            minus = true;
            b = readByte();
        }

        while (true) {
            if (b >= '0' && b <= '9') {
                num = num * 10 + (b - '0');
            } else {
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

    private void tr(Object... o) {
        if (INPUT.length() > 0) System.out.println(Arrays.deepToString(o));
    }

}