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>
import java.io.*;
import java.util.*;
 
import java.math.*;
import java.awt.Point;
 
public class Main {
    static final long MOD = 1000000007L;
    //static final long MOD2 = 1000000009L;
    //static final long MOD = 998244353L;
    //static final long INF = 500000000000L;
    static final int INF =   1000000005;
    static final int NINF = -1000000005;
    //static final long INF = 1000000000000000000L;
    static FastScanner sc;
    static PrintWriter pw;
    static final int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};

    public static void main(String[] args) {
        sc = new FastScanner();
        pw = new PrintWriter(System.out);

        int N = sc.ni();
        long[][] nums = new long[N][2];
        for (int i = 0; i < N; i++) {
            nums[i] = new long[]{sc.nl(),sc.nl()};
        }
        ArrayList<Line> lines = new ArrayList<Line>();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (i==j) continue;
                lines.add(new Line(nums,i,j));
            }
        }
        Collections.sort(lines);
        long[][][] dp = new long[N][N][6]; //start at i, end at j, contain k segments
        for (int i = 0; i < N; i++) dp[i][i][0] = 1;

        for (Line line: lines) {
            for (int i = 0; i < N; i++) {
                for (int k = 1; k <= 5; k++) {
                    dp[i][line.end][k] += dp[i][line.beg][k-1];
                }
            }
        }

        long ans = 0;
        for (int i = 0; i < N; i++) ans += dp[i][i][5];

        pw.println(ans);

        pw.close(); 
    }

    static class Line implements Comparable<Line> {
        int beg;
        int end;
        double ang;

        public Line(long[][] nums, int i, int j) {
            beg=i;
            end=j;
            long dy = nums[j][1]-nums[i][1];
            long dx = nums[j][0]-nums[i][0];
            long g = gcd(Math.abs(dy),Math.abs(dx));
            dy /= g;
            dx /= g;
            ang = Math.atan2(dy, dx);
        }

        public int compareTo(Line other) {
            if (ang < other.ang)
                return -1;
            else if (ang > other.ang)
                return 1;
            else
                return 0;
        }
    }

    public static long gcd(long a, long b) {
        if (a < b)
          return gcd(b,a);
        if (b == 0)
          return a;
        else
          return gcd(b,a%b);
    }
 
    public static void sort(int[] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr);
    }
 
    public static void sort(long[] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            long temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr);
    }
 
    //Sort an array (immune to quicksort TLE)
    public static void sort(int[][] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            int[] temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                return a[0]-b[0];
            }
        });
    }
    
    public static void sort(long[][] arr) {
        Random rgen = new Random();
        for (int i = 0; i < arr.length; i++) {
            int r = rgen.nextInt(arr.length);
            long[] temp = arr[i];
            arr[i] = arr[r];
            arr[r] = temp;
        }
        Arrays.sort(arr, new Comparator<long[]>() {
            @Override
            public int compare(long[] a, long[] b) {
                if (a[0] > b[0])
                    return 1;
                else if (a[0] < b[0])
                    return -1;
                else
                    return 0;
                //Ascending order.
            }
        });
    }
 
    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
 
        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in), 32768);
            st = null;
        }
 
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int ni() {
            return Integer.parseInt(next());
        }
 
        int[][] graph(int N, int[][] edges) {
            int[][] graph = new int[N][];
            int[] sz = new int[N];
            for (int[] e: edges) {
                sz[e[0]] += 1;
                sz[e[1]] += 1;
            }
            for (int i = 0; i < N; i++) {
                graph[i] = new int[sz[i]];
            }
            int[] cur = new int[N];
            for (int[] e: edges) {
                graph[e[0]][cur[e[0]]] = e[1];
                graph[e[1]][cur[e[1]]] = e[0];
                cur[e[0]] += 1;
                cur[e[1]] += 1;
            }
            return graph;
        }
 
        int[] intArray(int N, int mod) {
            int[] ret = new int[N];
            for (int i = 0; i < N; i++)
                ret[i] = ni()+mod;
            return ret;
        }

        char[] charArray(int N) {
            char[] ret = new char[N];
            for (int i = 0; i < N; i++)
                ret[i] = next().charAt(0);
            return ret;
        }
 
        long nl() {
            return Long.parseLong(next());
        }
 
        long[] longArray(int N, long mod) {
            long[] ret = new long[N];
            for (int i = 0; i < N; i++)
                ret[i] = nl()+mod;
            return ret;
        }
 
        double nd() {
            return Double.parseDouble(next());
        }
 
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}