You are given a set of n points in a 2D plane. No three points are collinear.

A pentagram is a set of 5 points A,B,C,D,E that can be arranged as follows. <image> Note the length of the line segments don't matter, only that those particular intersections exist.

Count the number of ways to choose 5 points from the given set that form a pentagram.

Input

The first line contains an integer n (5 ≤ n ≤ 300) — the number of points.

Each of the next n lines contains two integers x_i, y_i (-10^6 ≤ x_i,y_i ≤ 10^6) — the coordinates of the i-th point. It is guaranteed that no three points are collinear.

Output

Print a single integer, the number of sets of 5 points that form a pentagram.

Examples

Input


5
0 0
0 2
2 0
2 2
1 3


Output


1


Input


5
0 0
4 0
0 4
4 4
2 3


Output


0


Input


10
841746 527518
595261 331297
-946901 129987
670374 -140388
-684770 309555
-302589 415564
-387435 613331
-624940 -95922
945847 -199224
24636 -565799


Output


85

Note

A picture of the first sample: <image> A picture of the second sample: <image> A picture of the third sample: <image>
//package com.company;
// Always comment out package when submitting.

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    public static class Task {

        public static class Point implements Comparable<Point> {
            int x, y;
            int idx;
            boolean inPivot;

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

            public Point copy() {
                return new Point(this.x, this.y);
            }

            public void pivot(Point pivot) {
                if (inPivot) throw new RuntimeException();
                inPivot = true;
                x -= pivot.x;
                y -= pivot.y;
            }

            public void unpivot(Point pivot) {
                if (!inPivot) throw new RuntimeException();
                inPivot = false;
                x += pivot.x;
                y += pivot.y;
            }

            @Override
            public int compareTo(Point o) {
                int z1 = x == 0 && y == 0 ? 1 : 0;
                int z2 = o.x == 0 && o.y == 0 ? 1 : 0;
                if (z2 - z1 != 0) return z2 - z1;
                boolean up1 = y > 0 || (y == 0 && x >= 0);
                boolean up2 = o.y > 0 || (o.y == 0 && o.x >= 0);
                if (up1 != up2) return up1 ? -1 : 1;
                return Long.compare((long) x * o.y, (long) y * o.x);
            }

            @Override
            public String toString() {
                return this.x + " " + this.y;
            }


        }

//        int mod = 1_000_000_007;
        public long add(long a, long b) {
            return a + b;
//            int c = a + b;
//            if (c < 0) return c + mod;
//            if (c >= mod) return c - mod;
//            return c;
        }

        public int findPointWithIdx(Point[] points, int idx) {
            int found = -1;
            for (int i = 0; i < points.length; i++) {
                if (points[i].idx == idx) {
                    if (found != -1) throw new RuntimeException();
                    found = i;
                }
            }
            if (found == -1) throw new RuntimeException();
            return found;

        }

        public boolean isClockWise(Point a, Point b, Point c) { // return angle abc is clockwise or not
            int abX = b.x - a.x;
            int abY = b.y - a.y;
            int bcX = c.x - b.x;
            int bcY = c.y - b.y;
            return (long) abX * bcY < (long) abY * bcX;
        }

        public long solveForSet(Point[] points) {
            int n = points.length;
            if (n <= 2) return 0;
            for (int i = n - 1; i >= 0; i--) { // pivot itself last
                points[i].pivot(points[0]);
                points[i].inPivot = false; // this does not count..
            }
            Arrays.sort(points);
            if (points[0].x != 0 || points[0].y != 0) {
                throw new RuntimeException();
            }
            for (int i = 0; i < n; i++) {
                points[i].idx = i;
            }
            long[][][] dp = new long[n][n][3]; // i, j using side i->j, j -> 0, # of convex polygons, 0 + 3, 1 + 3, 2 + 3 vertices
            long sum = 0;
            for (int i = 1; i < n; i++) { // all points with 0 < idx < i are calculated
                Point pivot = points[i].copy();
                for (int j = 0; j < n; j++) {
                    points[j].pivot(pivot);
                }
                Arrays.sort(points);
                int originalStartIdx = findPointWithIdx(points, 0);
                int firstClockWiseIdx = -1;
                for (int shift = 0; shift < n - 1; shift++) {
                    int j = (originalStartIdx + shift);
                    if (j >= n) j -= n - 1;
                    if (isClockWise(points[originalStartIdx], points[0], points[j])) {
                        if (shift == 1) {
                            if (i != 1) {
                                throw new RuntimeException();
                            }
                        }
                        firstClockWiseIdx = j;
                        break;
                    }
                }
                if (firstClockWiseIdx == -1) {
                    if (i != n - 1) {
                        throw new RuntimeException();
                    }
                    break;
                }
                int beforeIdx = originalStartIdx + 1;
                if (beforeIdx >= n) beforeIdx -= n - 1;
                int afterIdx = firstClockWiseIdx;
                long[] sumBefore = new long[3];
                while ( afterIdx != originalStartIdx ) {
                    while ( beforeIdx != firstClockWiseIdx && isClockWise(points[beforeIdx], points[0], points[afterIdx]) ) {
                        for (int j = 0; j < 3; j++) {
                            sumBefore[j] = add(sumBefore[j], dp[points[beforeIdx].idx][points[0].idx][j]);
                        }
                        beforeIdx += 1;
                        if (beforeIdx >= n) beforeIdx -= n - 1;
                    }
                    dp[points[0].idx][points[afterIdx].idx][0] = 1;
                    for (int j = 0; j < 2; j++) {
                        dp[points[0].idx][points[afterIdx].idx][j + 1] = add(dp[points[0].idx][points[afterIdx].idx][j + 1], sumBefore[j]);
                    }
                    sum = add(sum, dp[points[0].idx][points[afterIdx].idx][2]);
                    afterIdx += 1;
                    if (afterIdx >= n) afterIdx -= n - 1;
                }

                for (int j = 0; j < n; j++) {
                    points[j].unpivot(pivot);
                }
                Arrays.sort(points, new Comparator<Point>() {
                    @Override
                    public int compare(Point p1, Point p2) {
                        return p1.idx - p2.idx;
                    }
                });
            }
            return sum;
        }

        public long calc(Point[] points) {
            Arrays.sort(points, new Comparator<Point>() {
                @Override
                public int compare(Point p1, Point p2) {
                    return p1.x - p2.x;
                }
            });
            long sol = 0;
            for (int i = 0; i < points.length; i++) {
                Point[] activePointSet = new Point[points.length - i];
                for (int j = i; j < points.length; j++) {
                    activePointSet[j - i] = points[j].copy();
                }
                sol = add(sol, solveForSet(activePointSet));
            }
            return sol;
        }


        public void solve(Scanner sc, PrintWriter pw) throws IOException {
            int n = sc.nextInt();
            Point[] points = new Point[n];

            for (int i = 0; i < n; i++) {
                int x = sc.nextInt();
                int y = sc.nextInt();
                points[i] = new Point(x, y);
            }

            pw.println(calc(points));
        }
    }

    // template, actual code is in class Task.
    static long TIME_START, TIME_END;

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
//        Scanner sc = new Scanner(new FileInputStream("Test.in"));
        PrintWriter pw = new PrintWriter(new BufferedOutputStream(System.out));
//        PrintWriter pw = new PrintWriter(new FileOutputStream("Test.out"));

//        createTestCases();
        Runtime runtime = Runtime.getRuntime();
        long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
        TIME_START = System.currentTimeMillis();
        Task t = new Task();
        t.solve(sc, pw);
        TIME_END = System.currentTimeMillis();
        long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
        pw.close();
//        System.err.println("Memory increased: " + (usedMemoryAfter - usedMemoryBefore) / 1000000);
//        System.err.println("Time used: " + (TIME_END - TIME_START) + ".");
    }

    // Faster IO with BufferedReader wrapped with Scanner
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader s) throws FileNotFoundException {
            br = new BufferedReader(s);
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {
            return br.readLine();
        }

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

        public boolean ready() throws IOException {
            return br.ready();
        }
    }
}