#include "bits/stdc++.h"

using namespace std;

using ld = long double;
constexpr ld eps = 1e-9;

bool eq(ld a, ld b)
{
    return (abs(a - b) < eps);
}

struct Point
{
    ld x, y, z;

    Point() : x(0), y(0), z(0) {}
    Point(ld x, ld y, ld z) : x(x), y(y), z(z) {}

    Point operator+(Point p)
    {
        return Point{x + p.x, y + p.y, z + p.z};
    }

    Point operator-(Point p)
    {
        return Point{x - p.x, y - p.y, z - p.z};
    }

    Point operator*(ld k)
    {
        return Point{k * x, k * y, k * z};
    }

    bool operator<(const Point &p) const
    {
        return (eq(x, p.x) ? (eq(y, p.y) ? z < p.z : y < p.y) : x < p.x);
    }

    bool operator==(const Point &p) const
    {
        return eq(x, p.x) && eq(y, p.y) && eq(z, p.z);
    }
};

using Vector = Point;

bool eq(Point a, Point b)
{
    return (eq(a.x, b.x) && eq(a.y, b.y) && eq(a.z, b.z));
}

ld norm(Point p)
{
    return p.x * p.x + p.y * p.y + p.z * p.z;
}

ld abs(Point p)
{
    return sqrt(norm(p));
}

ld dot(Point a, Point b)
{
    return (a.x * b.x + a.y * b.y + a.z + b.z);
}

Point cross(Point a, Point b)
{
    ld nx = a.y * b.z - b.y * a.z;
    ld ny = a.z * b.x - b.z * a.x;
    ld nz = a.x * b.y - b.x * a.y;
    return Point(nx, ny, nz);
}

ld cross2D(Point a, Point b)
{
    return a.x * b.y - b.x * a.y;
}

struct Line
{
    Point a, b;
    Line() : a(Point(0, 0, 0)), b(Point(0, 0, 0)) {}
    Line(Point a, Point b) : a(a), b(b) {}

    bool operator==(const Line &l) const
    {
        return (a == l.a && b == l.b) || (a == l.b && b == l.a);
    }
};

bool isis_lp(Line l, Point p)
{
    return (abs(cross(p - l.a, l.b - l.a)) < eps);
}

using ll = long long;
constexpr ll MOD = 998244353;

template <typename T>
void printv(const vector<T> &v)
{
    int sz = v.size();
    for (int i = 0; i < sz; i++)
    {
        cout << v[i] << " \n"[i == sz - 1];
    }
}

template <typename T>
T mypow(T a, T b)
{
    if (b == 0)
        return 1;
    T tmp = mypow(a, b / 2);
    if (b % 2)
        return (((tmp * tmp) % MOD) * a) % MOD;
    else
        return (tmp * tmp) % MOD;
}

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);

    ll n;
    cin >> n;
    ll ret = mypow(2LL, n);
    ret = (ret + MOD - 1) % MOD;
    ret = (ret + MOD - n) % MOD;
    vector<Point> ps;
    for (int i = 0; i < n; i++)
    {
        ld x, y;
        cin >> x >> y;
        ps.emplace_back(Point(x, y, 0));
    }
    set<vector<Point>> lines;
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            vector<Point> cand;
            cand.emplace_back(ps[i]);
            cand.emplace_back(ps[j]);
            for (int k = 0; k < n; k++)
            {
                if (k == i || k == j)
                    continue;
                if (isis_lp(Line(ps[i], ps[j]), ps[k]))
                {
                    cand.emplace_back(ps[k]);
                }
            }
            sort(cand.begin(), cand.end());
            lines.emplace(cand);
        }
    }
    for (const auto &l : lines)
    {
        ll k = l.size();
        ll tmp = mypow(2LL, k);
        tmp = (tmp + MOD - 1) % MOD;
        tmp = (tmp + MOD - k) % MOD;
        ret = (ret + MOD - tmp) % MOD;
    }
    cout << ret << endl;
}


Measured memory_bytes: 3712