import java.io.*;
import java.util.*;
import java.math.BigInteger;
import static java.lang.Math.*;

public class cottages_as_slow implements Runnable {

    class Point {
        int i;
        long x;
        long y;

        public Point(int i, long x, long y) {
            this.i = i;
            this.x = x;
            this.y = y;
        }

        public String toString() {
            return "(" + x + "," + y + ")";
        }
    }

    static boolean between(long x, long y, long z) {
        return (x <= y && y <= z) || (z <= y && y <= x);
    }

    public void solve() throws IOException {
        int zz = 0;

        Scanner in = new Scanner(new File("cottages.in"));
        PrintWriter out = new PrintWriter(new File("cottages.out"));

        int n = in.nextInt();

        Point[] p = new Point[n];
        for (int i = 0; i < n; i++) {
            p[i] = new Point(i, in.nextInt(), in.nextInt());
        }

        HashSet<Set<Integer>> ps = new HashSet<Set<Integer>>();
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i != j) {
                    long a = p[i].y - p[j].y;
                    long b = p[j].x - p[i].x;
                    long c = -(a * p[i].x + b * p[i].y);

                    long vi = b * p[i].x - a * p[i].y;
                    long vj = b * p[j].x - a * p[j].y;

                    HashSet<Integer> pp = new HashSet<Integer>();
                    HashSet<Integer> pn = new HashSet<Integer>();
                    boolean next = true;
                    for (int k = 0; k < n; k++) {
                        long d = a * p[k].x + b * p[k].y + c;
                        if (d > 0) {
                            pp.add(k);
                        } else if (d < 0) {
                            pn.add(k);
                        } else {
                            pp.add(k);
                            long vk = b * p[k].x - a * p[k].y;
                            if (between(vi, vk, vj)) {
                                next = false;
                            }
                        }
                    }
                    ps.add(pp);
                    ps.add(pn);

                    pp = new HashSet<Integer>();
                    pn = new HashSet<Integer>();
                    for (int k = 0; k < n; k++) {
                        long d = a * p[k].x + b * p[k].y + c;
                        if (d > 0) {
                            pp.add(k);
                        } else if (d < 0) {
                            pn.add(k);
                        } else {
                            long vk = b * p[k].x - a * p[k].y;
                            if (between(vk, vi, vj)) {
                                pp.add(k);
                            } else {
                                pn.add(k);
                            }
                        }
                    }
                    ps.add(pp);
                    ps.add(pn);
                }
            }
        }

        out.println(ps.size() - 2);

        in.close();
        out.close();
    }

    public void run() {
        try {
            solve();
        } catch (IOException e) {
            System.exit(64);
        }
    }

    public static void main(String[] arg) throws IOException {
        new Thread(new cottages_as_slow()).start();
    }
}