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

public class cottages_as implements Runnable {

    class Point implements Comparable<Point> {
        int i;
        long x;
        long y;
        double ang;

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

        public int compareTo(Point o) {
            return ang < o.ang - EPS ? -1 : ang > o.ang + EPS ? 1 : i - o.i;
        }

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

    int PN = 5;

    final static double EPS = 1e-10;

    class PointSet {
        int[] h;

        public PointSet(int[] h) {
            this.h = h.clone();
        }

        public boolean equals(Object o) {
            PointSet pointSet = (PointSet) o;
            return Arrays.equals(h, pointSet.h);
        }

        public int hashCode() {
            return Arrays.hashCode(h);
        }
    }

    static boolean eq(double x, double y) {
        return Math.abs(x - y) < EPS;
    }

    static double norm(double x) {
        while (x < 0) {
            x += 2 * PI;
        }
        while (x >= 2 * PI) {
            x -= 2 * PI;
        }
        return x;
    }

    static double dAngle(double from, double to) {
        from = norm(from);
        to = norm(to);
        if (from < to) {
            return to - from;
        } else {
            return to - from + 2 * PI;
        }
    }

    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();

        int[] px = new int[PN];
        Random random = new Random();
        int[][] v = new int[n][PN];
        for (int i = 0; i < PN; i++) {
            px[i] = (int) BigInteger.valueOf(random.nextInt(1000) + 1000).nextProbablePrime().intValue();
            int z = 1;
            for (int j = 0; j < n; j++) {
                v[j][i] = z;
                z = z * px[i];
            }
        }

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

        boolean debug = false;
        HashSet<PointSet> ps = new HashSet<PointSet>();

        for (int i = 0; i < n; i++) {
//            System.out.println(i + " " + ps.size());
            Point[] z = new Point[n - 1];
            int m = 0;
            for (int j = 0; j < n; j++) {
                if (i != j) {
                    z[m++] = p[j];
                    z[m - 1].ang = Math.atan2(p[j].y - p[i].y, p[j].x - p[i].x);
                    while (z[m - 1].ang < 0) {
                        z[m - 1].ang += 2 * PI;
                    }
                }
            }
            Arrays.sort(z);


            HashSet<Integer> hs1 = new HashSet<Integer>();
            HashSet<Integer> hs2 = new HashSet<Integer>();

            int[] h1 = new int[PN];
            int[] h2 = new int[PN];

            for (int k = 0; k < PN; k++) {
                h1[k] += v[i][k];
            }
            if (debug) {
                hs1.add(i);
            }

            int l = 0;
            int r = 0;
            int cnt = 0;
            while (r < m && z[r].ang <= z[l].ang + Math.PI + EPS) {
                for (int k = 0; k < PN; k++) {
                    h1[k] += v[z[r].i][k];
                }
                if (debug) {
                    hs1.add(z[r].i);
                }
                cnt++;
                r++;
            }

            for (int j = r; j < m; j++) {
                for (int k = 0; k < PN; k++) {
                    h2[k] += v[z[j].i][k];
                }
                if (debug) {
                    hs2.add(z[j].i);
                }
            }
            if (r == m) {
                r = 0;
            }
            int sr = r;
            int scnt = cnt;
            ps.add(new PointSet(h1));
            ps.add(new PointSet(h2));
            if (debug) {
                System.out.println("(" + i + ") " + hs1 + " " + hs2);
            }

            double ang = z[0].ang;
            do {
                if (eq(z[r].ang, norm(ang + PI))) {
                    int nr = r;
                    do {
                        for (int k = 0; k < PN; k++) {
                            h1[k] += v[z[nr].i][k];
                            h2[k] -= v[z[nr].i][k];
                        }
                        cnt++;
                        if (debug) {
                            hs1.add(z[nr].i);
                            hs2.remove(z[nr].i);
                        }
                        nr = (nr + 1) % m;
                    } while (eq(z[nr].ang, z[r].ang) && nr != r);
                    r = nr;
                    ps.add(new PointSet(h1));
                    ps.add(new PointSet(h2));
                    if (debug) {
                        System.out.println((zz++) + " (" + i + ") " + hs1 + " " + hs2);
                    }
                } else {
                    double dl = dAngle(ang, z[l].ang);
                    double dr = dAngle(ang + PI, z[r].ang);
                    int nl = l;
                    if (eq(z[l].ang, ang)) {
                        nl = l;
                        do {
                            for (int k = 0; k < PN; k++) {
                                h1[k] -= v[z[nl].i][k];
                                h2[k] += v[z[nl].i][k];
                            }
                            cnt--;
                            if (debug) {
                                hs1.remove(z[nl].i);
                                hs2.add(z[nl].i);
                            }

                            nl = (nl + 1) % m;
                        } while (eq(z[nl].ang, z[l].ang) && nl != l);
                        dl = dAngle(z[l].ang, z[nl].ang);
                        if (nl == l) {
                            dl = 2 * PI;
                        }
                        l = nl;
                    }
                    int nr = r;
                    if (eq(z[r].ang, norm(ang + PI))) {
                        nr = r;
                        do {
                            for (int k = 0; k < PN; k++) {
                                h1[k] += v[z[nr].i][k];
                                h2[k] -= v[z[nr].i][k];
                            }
                            cnt++;
                            if (debug) {
                                hs1.add(z[nr].i);
                                hs2.remove(z[nr].i);
                            }
                            nr = (nr + 1) % m;
                        } while (eq(z[nr].ang, z[r].ang) && nr != r);
                        dr = dAngle(z[r].ang, z[nr].ang);
                        if (nr == r) {
                            dr = 2 * PI;
                        }
                        r = nr;
                    }

                    if (dl <= dr + EPS) {
                        ang = z[l].ang;
                    } else {
                        ang = norm(z[r].ang - PI);
                    }
                    ps.add(new PointSet(h1));
                    ps.add(new PointSet(h2));
                    if (debug) {
                        System.out.println((zz++) + " (" + i + ") " + hs1 + " " + hs2);
                    }
                }
            } while (l != 0 || r != sr || cnt != scnt);
        }

        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()).start();
    }
}
