#include <iostream>
#include <sstream>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <numeric>
#include <algorithm>
#include <string>
#include <complex>

#include <cassert>
#include <cstdlib>
#include <cmath>
#include <cstdio>
#include <cstring>

#define REP(i,e) for(int i=0;i<(int)(e);i++)
#define FOR(i,b,e) for(int i=(int)(b);i<(int)(e);i++)
#define ALL(c) (c).begin(), (c).end()
#define EACH(it,c) for(__typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
#define RALL(c) (c).rbegin(), (c).rend()
#define ALLA(a,n) ((a)+0), ((a)+n)

using namespace std;

typedef long long ll;
typedef vector<int> vint;
typedef vector<long long> vll;
typedef vector<string> vstring;
typedef vector<double> vdouble;

template<class T>void pp(T v,int n){ REP(i,n)cout<<v[i]<< ' ' ; cout << endl; }
template<class T>void pp(T v){ EACH(it,v) cout << *it << ' ' ; cout << endl;  }
template<class T>T& ls(T& a,T b){ if(b<a) a=b; return a; }
template<class T>T& gs(T& a,T b){ if(b>a) a=b; return a; }
inline ll to_i(const string& s){ll n;sscanf(s.c_str(),"%lld",&n);return n;}
inline string to_s(ll n){char buf[32];sprintf(buf,"%lld",n);return string(buf);}

struct __scanner__{ bool e; operator bool(){ return e; } } IN = { false };
inline __scanner__& operator>>(__scanner__& in,int &n)
{ in.e = scanf("%d",&n)==1; return in; }
inline __scanner__& operator>>(__scanner__& in,ll &n)
{ in.e = scanf("%lld",&n)==1; return in; }
inline __scanner__& operator>>(__scanner__& in,double &n)
{ in.e = scanf("%lf",&n)==1; return in; }
inline __scanner__& operator>>(__scanner__& in,char &n)
{ in.e = scanf(" %c",&n)==1; return in; }
inline __scanner__& operator>>(__scanner__& in,string &n) // BUFFER SIZE!
{ static char buf[1000000]; in.e = scanf(" %s",buf)==1; n = buf; return in; } 

const ll MOD = 998244353;

// constants
const double eps=1e-9;
const double inf=1e256;
const double pi=3.1415926535897932;

// type definition
typedef complex<double> pt;
struct seg{ pt s,d; };
typedef seg line;

typedef vector<pt> gon;
typedef vector<pt> vpt;

// basic function
namespace std{
  bool operator<(const pt &a,const pt b){
    return a.real()<b.real() || (a.real()==b.real() && a.imag()<b.imag());
  }
}

inline bool eq(double a,double b){ return fabs(a-b)<eps; }
inline bool pteq(pt a,pt b){ return eq(real(a),real(b)) && eq(imag(a),imag(b));}

inline double dot  (pt a,pt b){ return real(conj(a)*b); }
inline double cross(pt a,pt b){ return imag(conj(a)*b); }

// counterclockwise
//                 +1
// +2 --- (l.s) ----0---> (l.d) --- -2
//                 -1            (Same as Mr. Maebara's)
inline int ccw(line l,pt p){
  p-=l.s;
  double c=cross(l.d-l.s,p);
  if(!eq(c,0)) return (c<0 ? -1 : 1);
  if(dot(l.d-l.s,p)<-eps) return 2;
  if(norm(l.d-l.s)+eps<norm(p)) return -2;
  return 0;
}

vll ps(256, 1);

ll compute(const vpt& v) {
  vector<line> u;
  REP(i,v.size()) REP(j,i) {
    bool ok = true;
    line t = { v[i], v[j] };
    REP(k,u.size()) if (abs(ccw(u[k], v[i])) != 1 && abs(ccw(u[k], v[j])) != 1) {
      // cout << u[k].s << "-" <<  u[k].d << ' '
      // 	   << v[i] << ' ' << ccw(u[k], v[i])
      // 	   << v[j] << ' ' << ccw(u[k], v[j]) << endl;
      ok = false; break;
    }
    if (ok) u.push_back((line) { v[i], v[j] });
  }
  // cout << "lines " << u.size() << endl; 
  // REP(i, u.size()) cout << u[i].s << ' ' << u[i].d << endl;
  
  ll result = ps[v.size()];
  // cout << "entire: " << result << endl;
  result -= 1;
  result -= v.size();
  result += MOD; result %= MOD;
  REP(i,u.size()) {
    ll cnt = 0;
    REP(j,v.size()) if (abs(ccw(u[i], v[j])) != 1) cnt++;
    // cout << "minus: " << cnt << ' ' << ps[cnt] - cnt - 1 << endl;
    result -= ps[cnt] - cnt - 1;
    result += MOD; result %= MOD;
  }

  return result;
}

int main(){
  FOR(i,1,ps.size()) ps[i] = ps[i-1] * 2 % MOD;
  int n;
  while (cin >> n) {
    vpt v(n);
    double x, y;
    REP(i,n) {
      cin >> x >> y;
      v[i] = pt(x, y);
    }
    cout << compute(v) << endl;
  }
}


Measured memory_bytes: 1404