Language: C++

#include <iostream>
#include <algorithm>
#include <vector>
#include <complex>
#include <cmath>
#include <cassert>
#include <tuple>

using namespace std;

constexpr long long mod = 998244353;
const double pi = acos(-1);

using P = complex<long long>;

long long dot(P a, P b) {
  return real(conj(a) * b);
}

long long cross(P a, P b) {
  return imag(conj(a) * b);
}

long long gcd(long long a, long long b) {
  a = abs(a);
  b = abs(b);
  if (b == 0) return a;
  return gcd(b, a % b);
}

P tomato(P a) {
  long long g = gcd(a.real(), a.imag());
  return P(a.real() / g, a.imag() / g);
}

P onion(P a) {
  long long g = gcd(a.real(), a.imag());
  return P(a.real() / g * 10010, a.imag() / g * 10010);
}

bool argcomp(std::complex<long long> p1, std::complex<long long> p2) {
  bool a = p1.imag() > 0 || (p1.imag() == 0 && p1.real() >= 0);
  bool b = p2.imag() > 0 || (p2.imag() == 0 && p2.real() >= 0);
  if (a != b) return a;
  long long c = p2.real() * p1.imag();
  long long d = p1.real() * p2.imag();
  if (c != d) return c < d;
  return std::norm(p1) < std::norm(p2);
}

namespace std {
  bool operator<(const P &a, const P &b) {
    return argcomp(a, b);
  }
}

int main() {
  int n;
  cin >> n;

  vector<P> ps(n);
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    ps[i] = P(x, y);
  }

  vector<pair<int, int>> es;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      if (i == j) continue;
      es.emplace_back(i, j);
    }
  }
  sort(es.begin(), es.end(), [&](pair<int, int> a, pair<int, int> b) {
    P d = ps[a.second] - ps[a.first];
    P e = ps[b.second] - ps[b.first];
    if (cross(d, e) == 0 && dot(d, e) >= 0) {
      return dot(ps[a.second] - ps[a.first], ps[b.first] - ps[a.first]) < 0;
    } else {
      return argcomp(d, e);
    }
  });

  vector<vector<pair<int, P>>> qs(n);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      if (i == j) continue;
      qs[i].emplace_back(0, ps[j] - ps[i]);
      qs[i].emplace_back(1, ps[j] - ps[i]);
    }
    sort(qs[i].begin(), qs[i].end());
  }

  static int in[200][200][200];
  static int on[200][200];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      if (i == j) continue;
      for (int k = 0; k < n; k++) {
        if (i == k || j == k) continue;
        in[i][j][k] = n;
        for (tuple<int, int, int> t : {make_tuple(i, j, k), make_tuple(k, i, j), make_tuple(j, k, i)}) {
          int x, y, z;
          tie(x, y, z) = t;
          P s = tomato(ps[y] - ps[x]);
          P t = onion(ps[z] - ps[y]);
          if (argcomp(s, t)) {
            int L = lower_bound(qs[y].begin(), qs[y].end(), make_pair(0, s)) - qs[y].begin();
            int R = upper_bound(qs[y].begin(), qs[y].end(), make_pair(0, t)) - qs[y].begin();
            in[i][j][k] -= R - L;
          } else {
            int L = lower_bound(qs[y].begin(), qs[y].end(), make_pair(0, s)) - qs[y].begin();
            int R = upper_bound(qs[y].begin(), qs[y].end(), make_pair(1, t)) - qs[y].begin();
            in[i][j][k] -= R - L;
          }
        }
        if (in[i][j][k] < 0) {
          in[i][j][k] = 0;
        }
        on[i][j] += cross(ps[k] - ps[i], ps[j] - ps[i]) == 0 && dot(ps[k] - ps[i], ps[j] - ps[i]) > 0 && dot(ps[k] - ps[j], ps[i] - ps[j]) > 0;
      }
    }
  }

  vector<long long> two(n + 1);
  two[0] = 1;
  for (int i = 1; i <= n; i++) {
    two[i] = two[i - 1] * 2 % mod;
  }

  long long ans = 0;
  for (int i = 0; i < n; i++) {
    vector<long long> dp1(n);
    vector<long long> dp2(n);
    for (auto e : es) {
      int u = e.first;
      int v = e.second;

      if (u == i) {
        assert(dp1[v] == 0);
        dp1[v] = two[on[u][v]];
      } else if (v == i) {
        dp2[v] += dp2[u];
      } else {
        int c = on[i][v] + on[u][v] + in[i][u][v];
        dp2[v] += dp1[u] * two[c];
        dp2[v] += dp2[u] * two[c];
      }
      dp2[v] %= mod;
    }
    ans += dp2[i];
    ans %= mod;
  }

  cout << ans << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:107:13: error: redeclaration of 'P t'
  107 |           P t = onion(ps[z] - ps[y]);
      |             ^
a.cc:103:35: note: 'std::tuple<int, int, int> t' previously declared here
  103 |         for (tuple<int, int, int> t : {make_tuple(i, j, k), make_tuple(k, i, j), make_tuple(j, k, i)}) {
      |                                   ^