stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll INF= 1LL << 60;

#define REP(i,n) for(ll i=0; i<n; i++)

#define FOR(i,a,n) for(ll i=a; i<n; i++)

#define tl 1'000'000'007

int mmax=10000;

void erasuru(vector<ll> &A){

    A[0] = 0; // 0は素数ではない

    A[1] = 0; // 1は素数ではない

    

    for(size_t i=2; i*i<=mmax; ++i) // 0からsqrt(max)まで調べる

        if(A[i]) // iが素数ならば

            for(size_t j=2; i*j<=mmax; ++j) // (max以下の)iの倍数は

                A[i*j] = 0;      // 素数ではない

}

int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    ll n;

    cin >> n;

    

    vector<ll>A(mmax,1);

    erasuru(A);

    ll ans= 1;

    

    REP(i,mmax){

        if(A[i]){

            ll cc= 0;

            ll x;

            for(ll j=2; j<=n; j++){ 

                x= j;

                while(x%i==0){

                    cc++;

                    x/=i;

                }

            }

            // cout << cc << endl;

            ans*= cc+1;

            ans%= tl;

        }

    }

    cout << ans << endl;



}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll INF= 1LL << 60;

#define REP(i,n) for(ll i=0; i<n; i++)

#define FOR(i,a,n) for(ll i=a; i<n; i++)

#define tl 1'000'000'007

int mmax;

void erasuru(vector<ll> &A){

    A[0] = 0; // 0は素数ではない

    A[1] = 0; // 1は素数ではない

    

    for(size_t i=2; i*i<=mmax; ++i) // 0からsqrt(max)まで調べる

        if(A[i]) // iが素数ならば

            for(size_t j=2; i*j<=mmax; ++j) // (max以下の)iの倍数は

                A[i*j] = 0;      // 素数ではない

}

int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    ll n;

    cin >> n;

    mmax= n;

    vector<ll>A(n+1,1);

    erasuru(A);

    ll ans= 1;

    

    REP(i,n+1){

        if(A[i]){

            ll cc= 0;

            ll x;

            for(ll j=2; j<=n; j++){ 

                x= j;

                while(x%i==0){

                    cc++;

                    x/=i;

                }

            }

            // cout << cc << endl;

            ans*= cc+1;

            ans%= tl;

        }

    }

    cout << ans << endl;



}

// Fastest known solution for this problem:
// Original C++ solution (slower):
// https://atcoder.jp/contests/abc052/tasks/arc067_a

#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using pii = pair<int, int>;

#define REP(i, n) for (int i = 0; i < n; i++)

#define REPR(i, n) for (int i = n - 1; i >= 0; i--)

#define FOR(i, m, n) for (int i = m; i < n; i++)

const int MOD = 1e9 + 7;



// constexprな素数列挙(エラトステネスの篩)

// https://259-momone.hatenablog.com/entry/2018/05/06/015026

template <size_t max_N, size_t prime_size> struct Prime {

    bool sieve[max_N];

    int_fast64_t prime[prime_size];

    size_t counter = 0;

    constexpr Prime() : sieve(), prime() {

        for (int_fast64_t i = 0; i < max_N; ++i)

            sieve[i] = true;

        sieve[0] = sieve[1] = false;

        for (int_fast64_t i = 2; i < max_N; ++i) {

            if (sieve[i]) {

                prime[counter] = i;

                ++counter;

                if (counter > prime_size)

                    break;

            }

            for (int_fast64_t j = i * i; j < max_N; j += i)

                sieve[j] = false;

        }

    }

};



int main() {

    ios::sync_with_stdio(false);

    cin.tie(0);

    int n;

    cin >> n;

    constexpr auto p = Prime<100000, 9592>();

    unordered_map<ll, ll> mp;

    ll ans = 1;

    FOR(i, 2, n + 1) {

        // 素数の場合

        if (p.sieve[i]) {

            // n!の中で素因数iは何乗か？

            ll tot = 0;

            for (int j = i; j <= n; j *= i) { // 2,4,8...

                tot += n / j;                 // 12/2 + 12/4 + 12/8

            }

            //約数の個数*(tot+1)%modで更新

            ans = (ans * (tot + 1)) % MOD;

        }

    }

    cout << ans << endl;



    return 0;

}


// Optimized solution to the same problem (faster):
// https://atcoder.jp/contests/abc052/tasks/arc067_a

#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using pii = pair<int, int>;

#define REP(i, n) for (int i = 0; i < n; i++)

#define REPR(i, n) for (int i = n - 1; i >= 0; i--)

#define FOR(i, m, n) for (int i = m; i < n; i++)

const int MOD = 1e9 + 7;



// constexprな素数列挙(エラトステネスの篩)

template <int N> struct Prime {

    bool b[N + 1]; // trueなら素数

    constexpr Prime() : b() {

        for (int_fast64_t i = 0; i <= N; ++i)

            b[i] = true;

        b[0] = b[1] = false;

        for (int_fast64_t i = 2; i <= N; ++i) {

            for (int_fast64_t j = i * i; j <= N; j += i)

                b[j] = false;

        }

    }

};



const int SZ = 1e3;



int main() {

    ios::sync_with_stdio(false);

    cin.tie(0);

    int n;

    cin >> n;

    constexpr auto prime = Prime<SZ>();

    ll ans = 1;

    FOR(i, 2, n + 1) {

        // 素数の場合

        if (prime.b[i]) {

            // n!の中で素因数iは何乗か？

            ll tot = 0;

            for (int j = i; j <= n; j *= i) { // 2,4,8...

                tot += n / j;                 // 12/2 + 12/4 + 12/8

            }

            //約数の個数*(tot+1)%modで更新

            ans = (ans * (tot + 1)) % MOD;

        }

    }

    cout << ans << endl;



    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int N, digit, counter;

bool ok = false;



int main()

{

        cin >> N;



        digit = N % 10;

        counter = 1;

        N /= 10;



        while (N > 0)

        {

                int currentDigit = N % 10;

                if (digit == currentDigit)

                {

                        ++counter;

                        if (counter == 3)

                                ok = true;

                }

                else

                {

                        digit = currentDigit;

                        counter = 1;

                }



                N /= 10;

        }



        if (ok == true)

                cout << "Yes";

        else

                cout << "No";



        return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main ()

{

    int n, a, b, c, d;

    scanf("%d", &n);

    a = n % 10;

    n /= 10;

    b = n % 10;

    n /= 10;

    c = n % 10;

    n /= 10;

    d = n;

    if (a == b && b == c)

        printf("Yes");

    else if (d == c && c == b)

        printf("Yes");

    else

        printf("No");



    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

char s[5];

int main(){

	cin>>s;

	if(s[0]==s[1]&&s[1]==s[2]||s[1]==s[2]&&s[2]==s[3])cout<<"Yes"<<endl;

	else cout<<"No"<<endl;

	return 0;

} 

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

    int n[5],i;

    for(i=1;i<=4;i++)

    scanf("%1d",&n[i]);

    if(n[1]==n[2]&&n[2]==n[3])

    {printf("Yes\n");

    return 0;}

    if(n[2]==n[3]&&n[3]==n[4])

    {printf("Yes\n");

    return 0;}

    printf("No\n");

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

string n;

int u[20];

int main()

{

    cin>>n;

    for(int s=2;s<n.size();s++)

    {

        if(n[s]==n[s-1]&&n[s]==n[s-2])

        {

            cout<<"Yes"<<endl;

            return 0;

        }

    }

    cout<<"No"<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

    int n[5],i;

    for(i=1;i<=4;i++)

    scanf("%1d",&n[i]);

    if(n[1]==n[2]&&n[2]==n[3])

    {printf("Yes\n");

    return 0;}

    if(n[2]==n[3]&&n[3]==n[4])

    {printf("Yes\n");

    return 0;}

    printf("No\n");

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstring>

using namespace std;

int main(){

	string c;

	cin>>c;

	for(int i=0;i<c.length();i++){

		if(c[i]==c[i+1]&&c[i+1]==c[i+2]) {

			cout<<"Yes"<<endl;

			return 0;

		}

	}

	cout<<"No"<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main()

{

    int n[5],i;

    for(i=1;i<=4;i++)

    scanf("%1d",&n[i]);

    if(n[1]==n[2]&&n[2]==n[3])

    {printf("Yes\n");

    return 0;}

    if(n[2]==n[3]&&n[3]==n[4])

    {printf("Yes\n");

    return 0;}

    printf("No\n");

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

#define all(v) v.begin(), v.end()

#define repi(i,n) for(int i=0;i<(int)(n);i++)

#define repd(i,n) for(int i=(int)(n);i>=0;i--)

#define repm(i,m) for(auto i=m.begin();i!=m.end();i++)



int main()

{

    int N;

    vector<int> X(N);

    vector<int> Y(N);

    

    cin >> N;

    repi(i,N){

        cin >> X[i] >> Y[i];

    }

    vector<int> path(N);

    repi(i,N){

        path[i] = i;

    }



    double sum = 0.0;

    do{

        repi(i,N-1){

            int dx = X.at(path.at(i)) - X.at(path.at(i+1));

            int dy = Y.at(path.at(i)) - Y.at(path.at(i+1));

            sum += pow(dx*dx + dy*dy, 0.5);

        }

    } while (next_permutation(all(path)));

    int Frac = 1;

    for(int i=2;i <= N;i++){

        Frac *= i;

    }

    cout << fixed << setprecision(10) << sum/Frac << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <iomanip>

#include <vector>

#include <algorithm>

#include <cmath>

typedef long long ll;

using namespace std;

const ll INF = 1e9;

const ll MOD = 1e9 + 7;

#define repi(i, n, init) for (ll i = init; i < (n); i++)



int main()

{

    int n;

    cin >> n;

    vector<int> order;

    vector<pair<int, int>> pos;

    repi(i, n, 0)

    {

        int x, y;

        cin >> x >> y;

        pos.push_back({x, y});

        order.push_back(i);

    }

    double ans = 0;

    double fact = 0;

    do

    {

        repi(i, n, 1)

        {

            ans += sqrt(pow(pos[order[i]].first - pos[order[i - 1]].first, 2) + pow(pos[order[i]].second - pos[order[i - 1]].second, 2));

        }

        fact++;

    } while (next_permutation(order.begin(), order.end()));

    cout << fixed << setprecision(10) << ans / fact << endl;

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <stdio.h>

#include <string.h>

#include <stdlib.h>

//#include <math.h>

//#include <algorithm>

#include <vector>



#define MIN(a, b) ((a)>(b)? (b): (a))

#define MAX(a, b) ((a)<(b)? (b): (a))



using namespace std;



int main(int argc, char* argv[])

{

    long n;

    scanf("%ld", &n);



    vector<long> a(n);

    vector<vector<long long> > gp(n+1, vector<long long>(n+1, 0));

 

    long i, j;

    for(i=0; i<n; i++) {

        scanf("%ld", &(a[i]));

        gp[i][0] = a[i];

    }



    for(j=1; j<n; j++) {

        for(i=0; i<n-j; i++) {

            gp[i][j] = MAX(a[i]-gp[i+1][j-1], a[i+j]-gp[i][j-1]);

        }

    }

   

    printf("%lld\n", gp[0][n-1]);



    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

#include <string>

#include <cstring>

#include <stdlib.h>

#include <math.h>

#include <algorithm>

#include <vector>

#include <set>

#include <map>

#include <queue>

#include <list>

#include <iterator>

#include <assert.h>

#pragma warning(disable:4996) 



typedef long long ll;

#define MIN(a, b) ((a)>(b)? (b): (a))

#define MAX(a, b) ((a)<(b)? (b): (a))

#define LINF 9223300000000000000

#define INF 2140000000

const long long MOD = 1000000007;

using namespace std;



ll dp[3005][3005];



int main(int argc, char* argv[])

{

    int n;

    scanf("%d", &n);



    int i,j;

    for(i=0; i<n; i++) {

        scanf("%d", &dp[i][1]);

    }

    for(j=2; j<=n; j++) {

        for(i=0; i<=n-j; i++) {

            dp[i][j]=MAX(-dp[i][j-1]+dp[i+j-1][1], -dp[i+1][j-1]+dp[i][1]);

        }

    }

    printf("%lld\n", dp[0][n]);



    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef long double ld;

typedef pair<int,int> P;

typedef pair<ll,ll> l_l;

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<ll> vl;

typedef vector<P> vp;

#define fi first

#define se second

#define rep(i,n) for(int i = 0; i < (n); ++i)

#define rrep(i,n) for(int i = 1; i <= (n); ++i)

#define drep(i,n) for(int i = (n)-1; i >= 0; --i)

const int INF=1001001000;

const int mINF=-1001001000;

const ll LINF=1010010010010010000;

template<class T> inline bool chmin(T& a, T b) {

if (a > b) {

a = b;

return true;

}

return false;

}

template<class T> inline bool chmax(T& a, T b) {

if (a < b) {

a = b;

return true;

}

return false;

}

//グリッド：（典型）dp,dfs,bfs,最短経路,その他

ll dp[3300][3300];



int main(){

    int n;cin >> n;

    vl a(n);rep(i,n) cin >> a[i];

    for(int i=0;i<3300;i++) dp[i][i]=0;

    for(int width=1;width<=n;width++){

        for(int l=0;l+width<=n;l++){

            int r=width+l;

            if(width%2==n%2){

                dp[l][r]=max(dp[l+1][r]+a[l],dp[l][r-1]+a[r-1]);

            }

            else{

                dp[l][r]=min(dp[l+1][r]-a[l],dp[l][r-1]-a[r-1]);

            }

        }

    }

    cout << dp[0][n] << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef long double ld;

typedef pair<int,int> P;

typedef pair<ll,ll> l_l;

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<ll> vl;

typedef vector<P> vp;

typedef pair<l_l,ll> lll;

typedef vector<string> vs;

const ll dx[4]={1,-1,0,0};

const ll dy[4]={0,0,1,-1};

#define pb push_back

#define sz(x) (int)(x).size()

#define fi first

#define se second

#define rep(i,n) for(int i = 0; i < (n); ++i)

#define rrep(i,n) for(int i = 1; i <= (n); ++i)

#define drep(i,n) for(int i = (n)-1; i >= 0; --i)

const int INF=1001001000;

const int mINF=-1001001000;

const ll LINF=1010010010010010000;

template<class T> inline bool chmin(T& a, T b) {

if (a > b) {

a = b;

return true;

}

return false;

}

template<class T> inline bool chmax(T& a, T b) {

if (a < b) {

a = b;

return true;

}

return false;

}

ll n;

ll a[3300];

ll dp[3300][3300];

int main(){

    cin>>n;

    rep(i,n)cin>>a[i];

    rep(i,n)dp[i][i]=0;

    for(int len=1;len<=n;len++){

        for(int i=0;i<n;i++){

            int j=i+len;

            if(j>n)continue;

            if((n-len)%2==1){

                dp[i][j]=min(dp[i+1][j]-a[i],dp[i][j-1]-a[j-1]);

            }else{

                dp[i][j]=max(dp[i+1][j]+a[i],dp[i][j-1]+a[j-1]);

            }

        }

    }

    cout<<dp[0][n]<<endl;

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

const int P=998244353;

int n;

struct pos{

	int x,y;

}ps[1007];

int ep=0,f[1007],sz[1007];

int gf(int x){while(x!=f[x])x=f[x]=x[f][f];return x;}

struct edge{

	int a,b;

	int v;

	bool operator<(const edge&e)const{return v<e.v;}

	void cal(){

		int x=gf(a),y=gf(b);

		if(x!=y)f[x]=y,sz[y]+=sz[x];

	}

}es[207*207];

int gcd(int a,int b){

	return b?gcd(b,a%b):a;

}

int pw[1007],ans;

int main(){

	scanf("%d",&n);

	pw[0]=1;

	for(int i=1;i<=n;++i)pw[i]=pw[i-1]*2%P;

	ans=(pw[n]-n-1)%P;

	for(int i=0;i<n;++i)scanf("%d%d",&ps[i].x,&ps[i].y);

	for(int i=0;i<n;++i){

		for(int j=0;j<i;++j){

			int x=ps[i].x-ps[j].x,y=ps[i].y-ps[j].y;

			int g=gcd(x,y);

			x/=g,y/=g;

			if(!x)y=1;

			if(!y)x=1;

			if(x<0)x=-x,y=-y;

			es[ep++]=(edge){i,j,x*30000+y};

		}

	}

	std::sort(es,es+ep);

	for(int i=0,j=0;i<ep;i=j){

		for(int a=0;a<n;++a)sz[f[a]=a]=1;

		for(;j<ep&&es[i].v==es[j].v;es[j++].cal());

		for(int a=0;a<n;++a)if(f[a]==a&&sz[a]>1)ans=(ans-pw[sz[a]]+sz[a]+1)%P;

	}

	printf("%d\n",(ans%P+P)%P);

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<cstring>

#include<algorithm>

const int M=207,mod=998244353;

int read(){

	int ans=0,f=1,c=getchar();

	while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}

	while(c>='0'&&c<='9'){ans=ans*10+(c-'0'); c=getchar();}

	return ans*f; 

}

int n,f[M],sz[M];

int find(int x){while(f[x]!=x) x=f[x]=f[f[x]]; return x;}

int gcd(int x,int y){return y?gcd(y,x%y):x;} 

struct pos{int x,y;}q[M];

int cnt;

struct node{

	int u,v,w;

	bool operator <(const node &x)const{return w<x.w;}

	void calc(){

		int p=find(u),q=find(v);

		if(p!=q) f[q]=p,sz[p]+=sz[q];

	}

}e[M*M];

int pw[M],ans;

void prepare(){

	pw[0]=1; 

	for(int i=1;i<=n;i++) pw[i]=(pw[i-1]<<1)%mod;

}

int main(){

	n=read(); 

	prepare(); ans=(pw[n]-n-1)%mod;

	for(int i=1;i<=n;i++) q[i].x=read(),q[i].y=read();

	for(int i=1;i<=n;i++)

		for(int j=1;j<i;j++){

			int x=q[i].x-q[j].x,y=q[i].y-q[j].y,g=gcd(x,y);

			x/=g; y/=g;

			if(!x) y=1;

			if(!y) x=1;

			if(x<0) x=-x,y=-y;

			e[++cnt]=(node){i,j,x*30000+y};

		}

	std::sort(e+1,e+1+cnt);

	for(int i=1,j=1;i<=cnt;i=j){

		for(int k=1;k<=n;k++) sz[f[k]=k]=1;

		while(j<=cnt&&e[j].w==e[i].w) e[j++].calc();

		for(int k=1;k<=n;k++) if(f[k]==k&&sz[k]>=2) ans=(ans-pw[sz[k]]+sz[k]+1)%mod;

	}printf("%d\n",(ans+mod)%mod);

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstdio>

using namespace std;



#define mod 998244353

int n,x[205],y[205];



int qpow(int x,int y){

	int ans=1;

	while(y){

		if(y&1)ans=1LL*ans*x%mod;

		y>>=1,x=1LL*x*x%mod;

	}

	return ans;

}



bool check(int i,int j,int k){

	int a=1LL*(y[j]-y[i])*(x[k]-x[j])%mod;

	int b=1LL*(y[k]-y[j])*(x[j]-x[i])%mod;

	return a==b;

}



int main(){

	scanf("%d",&n);

	for(int i=1;i<=n;i++)

		scanf("%d%d",x+i,y+i);

	int ans=((qpow(2,n)-(1LL*n*(n-1)>>1)%mod-n-1)%mod+mod)%mod;

	for(int i=1;i<=n;i++){

		for(int j=i+1;j<=n;j++){

			int sum=0;

			for(int k=j+1;k<=n;k++){

				if(k==i||k==j)continue;

				if(check(i,j,k))sum++;

			}

			ans=(ans-qpow(2,sum)+1+mod)%mod;

		}

	}

	printf("%d",ans);

	

} 

// Optimized solution to the same problem (faster):
#include <cstdio>



int read()

{

  int x=0,f=1;

  char ch=getchar();

  while((ch<'0')||(ch>'9'))

    {

      if(ch=='-')

        {

          f=-f;

        }

      ch=getchar();

    }

  while((ch>='0')&&(ch<='9'))

    {

      x=x*10+ch-'0';

      ch=getchar();

    }

  return x*f;

}



const int maxn=200;

const int mod=998244353;



struct point

{

  int x,y;

};



point p[maxn+10];

int n,ans;



int quickpow(int a,int b,int m)

{

  int res=1;

  while(b)

    {

      if(b&1)

        {

          res=1ll*res*a%m;

        }

      a=1ll*a*a%m;

      b>>=1;

    }

  return res;

}



int in_line(point a,point b,point c)

{

  return (b.y-a.y)*(c.x-a.x)==(c.y-a.y)*(b.x-a.x);

}



int main()

{

  n=read();

  for(int i=1; i<=n; ++i)

    {

      p[i].x=read();

      p[i].y=read();

    }

  for(int i=1; i<=n; ++i)

    {

      for(int j=i+1; j<=n; ++j)

        {

          int cnt=0;

          for(int k=j+1; k<=n; ++k)

            {

              if(in_line(p[i],p[j],p[k]))

                {

                  ++cnt;

                }

            }

          ans+=quickpow(2,cnt,mod);

          if(ans>=mod)

            {

              ans-=mod;

            }

        }

    }

  ans+=n+1;

  if(ans>=mod)

    {

      ans-=mod;

    }

  ans=quickpow(2,n,mod)-ans;

  if(ans<0)

    {

      ans+=mod;

    }

  printf("%d\n",ans);

  return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;



template <typename _tp> inline void read(_tp&x){

	char ch=getchar(),ob=0;x=0;

	while(ch!='-'&&!isdigit(ch))ch=getchar();if(ch=='-')ob=1,ch=getchar();

	while(isdigit(ch))x=x*10+ch-'0',ch=getchar();if(ob)x=-x;

}



const int N = 203, mod = 998244353;



struct pnt {

	int x, y;

	inline void in() {read(x), read(y);}

	friend inline pnt operator - (const pnt&A, const pnt&B) {return (pnt) {A.x - B.x, A.y - B.y};}

	friend inline int operator * (const pnt&A, const pnt&B) {return A.x * B.y - A.y * B.x;}

} p[N];



inline bool con(const pnt&A, const pnt&B, const pnt&C) {

	return (C - A) * (B - A) == 0;

}



int n;

int bin[N];

bool vs[N];

ll Ans;



int main() {

	read(n);

	bin[0] = 1;

	for(int i=1;i<=n;++i) bin[i] = (bin[i-1] << 1)%mod;

	for(int i=1;i<=n;++i) p[i].in();

	for(int i=1;i<n;++i) {

		for(int j=1;j<=n;++j) vs[j] = false;

		

		for(int j=i+1;j<=n;++j)

			if(!vs[j]) {

				bool flg = true;

				for(int k=1;k<i;++k)

					if(con(p[i], p[j], p[k]))

						flg = false;

				int ct = 2;

				for(int k=j+1;k<=n;++k)

					if(con(p[i], p[j], p[k]))

						vs[k] = true, ++ct;

				if(flg) Ans += bin[ct] - ct - 1;

			}

	}

	Ans = ((ll)mod*mod - Ans - n - 1 + bin[n])%mod;

	printf("%lld\n", Ans);

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

typedef long long ll;



const int N = 203, mod = 998244353;



struct pnt {

	int x, y;

	inline void in() {scanf("%d%d", &x, &y);}

	friend inline pnt operator - (const pnt&A, const pnt&B) {return (pnt) {A.x - B.x, A.y - B.y};}

	friend inline int operator * (const pnt&A, const pnt&B) {return A.x * B.y - A.y * B.x;}

} p[N];



inline bool con(const pnt&A, const pnt&B, const pnt&C) {

	return (C - A) * (B - A) == 0;

}



int n;

int bin[N];

bool vs[N];

ll Ans;



int main() {

	scanf("%d", &n);

	for(int i=bin[0]=1;i<=n;++i) bin[i] = (bin[i-1] << 1)%mod;

	for(int i=1;i<=n;++i) p[i].in();

	for(int i=1;i<n;++i) {

		for(int j=1;j<=n;++j) vs[j] = false;

		

		for(int j=i+1;j<=n;++j)

			if(!vs[j]) {

				int ct = 2;

				for(int k=j+1;k<=n;++k)

					if(con(p[i], p[j], p[k])) vs[k] = true, ++ct;

				

				bool flg = true;

				for(int k=1;k<i and flg;++k)

					if(con(p[i], p[j], p[k])) flg = false;

				if(flg) Ans += bin[ct] - ct - 1;

			}

	}

	Ans = ((ll)mod*mod - Ans - n - 1 + bin[n])%mod;

	printf("%lld\n", Ans);

	return 0;

}

// Fastest known solution for this problem: