Problem:
Score : 700 points

Problem Statement

You are given N points (x_i,y_i) located on a two-dimensional plane.
Consider a subset S of the N points that forms a convex polygon.
Here, we say a set of points S forms a convex polygon when there exists a convex polygon with a positive area that has the same set of vertices as S. All the interior angles of the polygon must be strictly less than 180°.

For example, in the figure above, {A,C,E} and {B,D,E} form convex polygons; {A,C,D,E}, {A,B,C,E}, {A,B,C}, {D,E} and {} do not.

For a given set S, let n be the number of the points among the N points that are inside the convex hull of S (including the boundary and vertices). Then, we will define the score of S as 2^{n-|S|}.

Compute the scores of all possible sets S that form convex polygons, and find the sum of all those scores.

However, since the sum can be extremely large, print the sum modulo 998244353.

Constraints

1≤N≤200

0≤x_i,y_i<10^4 (1≤i≤N)

If i≠j, x_i≠x_j or y_i≠y_j.

x_i and y_i are integers.

Input

The input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_N y_N

Output

Print the sum of all the scores modulo 998244353.

Sample Input 1

4
0 0
0 1
1 0
1 1

Sample Output 1

5

We have five possible sets as S, four sets that form triangles and one set that forms a square. Each of them has a score of 2^0=1, so the answer is 5.

Sample Input 2

5
0 0
0 1
0 2
0 3
1 1

Sample Output 2

11

We have three "triangles" with a score of 1 each, two "triangles" with a score of 2 each, and one "triangle" with a score of 4. Thus, the answer is 11.

Sample Input 3

1
3141 2718

Sample Output 3

0

There are no possible set as S, so the answer is 0.

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
class Solve{
    public Solve(){}
    StringBuilder sb;
    ReadData re;
    public static int Main(){
        new Solve().Run();
        return 0;
    }
    void Run(){
        sb = new StringBuilder();
        re = new ReadData();
        Calc();
        Console.Write(sb.ToString());
    }
    void Calc(){
        int N = re.i();
        int[] X = new int[N];
        int[] Y = new int[N];
        for(int i=0;i<N;i++){
            X[i] = re.i();
            Y[i] = re.i();
        }
        long[] Po = new long[N+1];
        Po[0] = 1;
        for(int i=1;i<=N;i++){
            Po[i] = Po[i-1] * 2 % Define.mod;
        }
        long count = Po[N];
        count += Define.mod - (1 + N);
        count %= Define.mod;
        Data[] D = new Data[N*(N-1)/2];
        int c = 0;
        for(int i=0;i<N;i++){
            for(int j=i+1;j<N;j++){
                int x = X[i] - X[j];
                int y = Y[i] - Y[j];
                D[c] = new Data(x,y,i,j);
                c++;
            }
        }
        Array.Sort(D,(a,b)=>(a.x == 0 ? -100000000 : b.x*a.y) - (b.x == 0 ? -100000000 : a.x*b.y));
        int[] A = new int[N];
        int[] B = new int[N];
        for(int i=0;i<N;i++){
            A[i] = -1;
            B[i] = -1;
        }
        for(int i=0;i<c;i++){
            Data d = D[i];
            int p = d.p1;
            if(A[p] == -1){
                A[p] = i;
                B[p] = 1;
            }
            else if(SameR(d,D[A[p]])){
                if(B[p] != -1){
                    B[p]++;
                }
            }
            else{
                count += Define.mod - Po[B[p]+1] + (2 + B[p]);
                count %= Define.mod;
                A[p] = i;
                B[p] = 1;
            }
            p = d.p2;
            if(A[p] != -1 && !SameR(d,D[A[p]])){
                count += Define.mod - Po[B[p]+1] + (2 + B[p]);
                count %= Define.mod;
            }
            A[p] = i;
            B[p] = -1;
        }
        for(int i=0;i<N;i++){
            count += Define.mod - Po[B[i]+1] + (2 + B[i]);
            count %= Define.mod;
        }
        sb.Append(count+"\n");
    }
    bool SameR(Data a,Data b){
        return (a.x == 0 ? -100000000 : b.x*a.y) == (b.x == 0 ? -100000000 : a.x*b.y);
    }
}
class Data{
    public int x;
    public int y;
    public int p1;
    public int p2;
    public Data(int x0,int y0,int i,int j){
        if(x0 > 0){
            x = x0;
            y = y0;
        }
        else{
            x = -x0;
            y = -y0;
        }
        p1 = i;
        p2 = j;
    }
}
class ReadData{
    string[] str;
    int counter;
    public ReadData(){
        counter = 0;
    }
    public string s(){
        if(counter == 0){
            str = Console.ReadLine().Split(' ');
            counter = str.Length;
        }
        counter--;
        return str[str.Length-counter-1];
    }
    public int i(){
        return int.Parse(s());
    }
    public long l(){
        return long.Parse(s());
    }
    public double d(){
        return double.Parse(s());
    }
    public int[] ia(int N){
        int[] ans = new int[N];
        for(int j=0;j<N;j++){
            ans[j] = i();
        }
        return ans;
    }
    public int[] ia(){
        str = Console.ReadLine().Split(' ');
        counter = 0;
        int[] ans = new int[str.Length];
        for(int j=0;j<str.Length;j++){
            ans[j] = int.Parse(str[j]);
        }
        return ans;
    }
    public long[] la(int N){
        long[] ans = new long[N];
        for(int j=0;j<N;j++){
            ans[j] = l();
        }
        return ans;
    }
    public long[] la(){
        str = Console.ReadLine().Split(' ');
        counter = 0;
        long[] ans = new long[str.Length];
        for(int j=0;j<str.Length;j++){
            ans[j] = long.Parse(str[j]);
        }
        return ans;
    }
    public double[] da(int N){
        double[] ans = new double[N];
        for(int j=0;j<N;j++){
            ans[j] = d();
        }
        return ans;
    }
    public double[] da(){
        str = Console.ReadLine().Split(' ');
        counter = 0;
        double[] ans = new double[str.Length];
        for(int j=0;j<str.Length;j++){
            ans[j] = double.Parse(str[j]);
        }
        return ans;
    }
    public List<int>[] g(int N,int[] f,int[] t){
        List<int>[] ans = new List<int>[N];
        for(int j=0;j<N;j++){
            ans[j] = new List<int>();
        }
        for(int j=0;j<f.Length;j++){
            ans[f[j]].Add(t[j]);
            ans[t[j]].Add(f[j]);
        }
        return ans;
    }
    public List<int>[] g(int N,int M){
        List<int>[] ans = new List<int>[N];
        for(int j=0;j<N;j++){
            ans[j] = new List<int>();
        }
        for(int j=0;j<M;j++){
            int f = i()-1;
            int t = i()-1;
            ans[f].Add(t);
            ans[t].Add(f);
        }
        return ans;
    }
    public List<int>[] g(){
        int N = i();
        int M = i();
        List<int>[] ans = new List<int>[N];
        for(int j=0;j<N;j++){
            ans[j] = new List<int>();
        }
        for(int j=0;j<M;j++){
            int f = i()-1;
            int t = i()-1;
            ans[f].Add(t);
            ans[t].Add(f);
        }
        return ans;
    }
}
public static class Define{
    public const long mod = 998244353;
}