//pragma
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>

#define YOU using
#define DONT namespace
#define SAY std

YOU DONT SAY;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ll,int> pli;
typedef pair<int,ll> pil;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<pll> vll;

#define REPP(i,a,b,d) for(int i=a;i<=b;i+=d)
#define REP(i,a,b) REPP(i,a,b,1)
#define REVV(i,a,b,d) for(int i=a;i>=b;i-=d)
#define REV(i,a,b) REVV(i,a,b,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

#define pb push_back
#define F first
#define S second

const int OO = 1e9;
const ll INF = 1e18;

const int irand(int lo,int hi){
	return ((double)rand()/(RAND_MAX + 1.0)) * (hi-lo+1) + lo;
}

const ll lrand(ll lo,ll hi){
	return ((double)rand()/(RAND_MAX + 1.0)) * (hi-lo+1) + lo;
}

#define getc getchar
template<typename T>
T getnum(){
	int sign = 1;
	T ret = 0;
	char c;

	do{
		c = getc();
	}while(c == ' ' || c == '\n');
	if(c == '-')sign = -1;
	else ret = c-'0';
	while(1){
		c = getc();
		if(c < '0' || c > '9')break;
		ret = 10*ret + c-'0';
	}
	return sign * ret;
}

inline void ini(int& x){
	x = getnum<int>();
}

inline void scani(int& x){
	scanf("%d",&x);
}

//end of macro

const ll MOD = 998244353;

inline ll addmod(ll a, ll b){
    if(a+b < MOD)return a+b;
    return a+b-MOD;
}
inline ll submod(ll a, ll b){
	return addmod(a, MOD-b);
}
inline ll mulmod(ll a, ll b){
    return (a*b)%MOD;
}
inline ll expmod(ll a, ll e){
    ll ret = 1;
    while(e){
        if(e&1)ret = mulmod(ret, a);
        a = mulmod(a, a);
        e >>= 1;
    }
    return ret;
}

const int N = 205;

int n;
int x[N], y[N];
bool used[N];

int piv;
vi pts;
int cross(int a, int b, int c){
    return (x[b]-x[a]) * (y[c]-y[a]) - (y[b]-y[a]) * (x[c]-x[a]);
}
int dist2(int a, int b){
    return (x[a]-x[b])*(x[a]-x[b]) + (y[a]-y[b])*(y[a]-y[b]);
}
bool cmp(int a, int b){
    if(cross(piv, a, b) == 0)return dist2(piv, a) < dist2(piv, b);
    return cross(piv, a, b) > 0;
}

int bitt[N];
void update(int x, int v){
    REPP(i,x,N-1,i&-i)bitt[i] += v;
}
int query(int x){
    int ret = 0;
    REVV(i,x,1,i&-i)ret += bitt[i];
    return ret;
}

int arr[N];
int dp[N];
int receive[N][N]; // receive[i][j] means the current value received by i from j
int tidx[N];
vi pts2;
int solve(int sz){
//    printf("-------------  solve %d  ------------------\n",sz);
    arr[1] = piv;
    REP(i,2,sz)arr[i] = pts[i-2];
    
//    printf("points\n");
//    REP(i,1,sz)printf("%d %d\n",x[arr[i]], y[arr[i]]);
    
    int ret = 0;
    REP(i,2,sz){
//    	printf(">>> processing %d\n",i);
        dp[i] = 0;
        receive[arr[i]][arr[1]] = 1; // start new
        
        // extend : j --- i
        piv = arr[i];
        pts.clear(); pts2.clear();
        REV(j,i-1,1){
            pts.pb(arr[j]);
        }
        REP(j,i+1,sz){
        	pts2.pb(arr[j]);
		}
        sort(pts.begin(), pts.end(), cmp);
        sort(pts2.begin(), pts2.end(), cmp);
        FOR(i,pts.size()){
            tidx[pts[i]] = i+1;
        }
        memset(bitt, 0, sizeof bitt);
        // add the points to receive[i][j]
        REV(j,i-1,1){
            int inside = query(tidx[arr[j]]);
            update(tidx[arr[j]], 1);
            //if(cross(arr[1], arr[i], arr[j]) == 0)continue; // cannot extend from co-linear
            //dp[i] = addmod(dp[i], mulmod(dp[j], expmod(2, inside)));
            receive[arr[i]][arr[j]] = mulmod(receive[arr[i]][arr[j]], expmod(2, inside));
        }
        
        // fill dp and the receive of the next points
        int p = 0; // pointer for pts
		FOR(j,pts2.size()){
        	while(p < pts.size() && cross(pts[p], arr[i], pts2[j]) > 0){
        		dp[i] = addmod(dp[i], receive[arr[i]][pts[p]]);
//        		printf("received %d %d <- %d %d, %d\n",x[arr[i]],y[arr[i]],x[pts[p]],y[pts[p]],receive[arr[i]][pts[p]]);
        		p++;
			}
			receive[pts2[j]][arr[i]] = dp[i];
//			printf("push value %d %d -> %d %d, %d\n",x[arr[i]],y[arr[i]],x[pts2[j]],y[pts2[j]],dp[i]);
		}
		while(p < pts.size()){
			dp[i] = addmod(dp[i], receive[arr[i]][pts[p]]);
//        	printf("received %d %d <- %d %d, %d\n",x[arr[i]],y[arr[i]],x[pts[p]],y[pts[p]],receive[arr[i]][pts[p]]);
        	p++;
		}
        
        // close polygon : i --- 1
        ret = addmod(ret, submod(dp[i], receive[arr[i]][arr[1]]));
        
//        printf("dp %d = %d\n",i,dp[i]);
    }
//    printf("ret %d = %d\n",sz,ret);
    return ret;
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    #define endl '\n'
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(10);
    
    cin>>n;
    REP(i,1,n){
        cin>>x[i]>>y[i];
    }
    
    int ans = 0;
    REV(sz,n,3){
        piv = -1;
        REP(i,1,n){
            if(used[i])continue;
            if(piv == -1 || (y[i] < y[piv]) || (y[i] == y[piv] && x[i] < x[piv]))piv = i;
        }
        
        used[piv] = true;
        
        pts.clear();
        REP(i,1,n){
            if(used[i])continue;
            pts.pb(i);
        }
        sort(pts.begin(), pts.end(), cmp);
        
//        printf("pivot %d\n",piv);
//        FOR(i,pts.size())printf("%d\n",pts[i]);
        
        ans = addmod(ans, solve(sz));
    }
    
    cout << ans << endl;
    
    return 0;
}

Measured memory_bytes: 384