import java.io.*;
import java.util.*;

public class TaskE_n2log {
    private final InputReader reader;
    private final OutputWriter writer;

    public TaskE_n2log(InputReader reader, OutputWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWriter writer = new OutputWriter(System.out);
        new TaskE_n2log(reader, writer).run();
        writer.writer.flush();
    }

    int[][] gcd;

    int mygcd(int a, int b) {
        return gcd[Math.abs(a)][Math.abs(b)];
    }

    public void run() {
        int n = reader.nextInt();
        int ans = (int) (n * (n - 1) * 1l * (n - 2) / 6);
        gcd = new int[201][201];
        gcd[0][0] = 0;
        for (int i = 0; i <= 200; i++) {
            gcd[i][i] = i;
            for (int j = 0; j < i; j++)
                gcd[j][i] = gcd[i][j] = (j == 0) ? i : gcd[j][i % j];
        }
        int[] X = new int[n], Y = new int[n];
        for (int i = 0; i < n; i++) {
            X[i] = reader.nextInt();
            Y[i] = reader.nextInt();
        }
        long[] H = new long[n * (n - 1) / 2];
        int hpt = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                int A = Y[i] - Y[j], B = -X[i] + X[j];
                int C = A * X[i] + B * Y[i];
                int g = mygcd(A, B);
                A /= g;
                B /= g;
                C /= g;
                if (A < 0 || (A == 0 && B < 0)) {
                    A = -A;
                    B = -B;
                    C = -C;
                }
                long hsh = C * 500 * 1l * 500 + (A + 250) * 500 + B;
                H[hpt++] = hsh;
            }
        }
        Arrays.sort(H);

        int[] cnt = new int[n * n];
        Arrays.fill(cnt, -1);
        for (int i = 2; i <= n; i++)
            cnt[i * (i - 1) / 2] = i;

        for (int l = 0, r = 0; l < H.length; l = r) {
            while (r != H.length && H[l] == H[r])
                r++;
            int q = r - l;
            int v = cnt[r - l];
            ans -= v * (v - 1) * 1l * (v - 2) / 6;
        }
        writer.printf("%d\n", ans);
    }


    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}