#include <bits/stdc++.h>
using namespace std;
#define int int64_t

mt19937_64 rnd;

struct Vector {
    int x;
    int y;

    Vector(int x = 0, int y = 0): x(x), y(y) {}
    Vector(const Vector& u, const Vector& v): x(v.x - u.x), y(v.y - u.y) {}

    int sqlen() const { return x * x + y * y; }
};

Vector operator-(const Vector& a, const Vector& b) {
    return Vector(b, a);
}

int operator%(const Vector& a, const Vector& b) {
    return a.x * b.y - a.y * b.x;
}

bool hp(const Vector& v) {
    if (v.y == 0) return v.x > 0;
    return v.y > 0;
}

bool operator<(const Vector& u, const Vector& v) {
    if (hp(u) == hp(v)) {
        return u % v > 0;
    }
    return hp(u);
}

istream& operator>>(istream& in, Vector& v) {
    in >> v.x >> v.y;
    return in;
}

void solve() {
    int n;
    cin >> n;
    vector<Vector> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    if (n == 1) {
        cout << "1\n";
        return;
    }

    vector<Vector> hull;
    int sz = 0;
    vector<Vector> cent;
    Vector min_p = a[0];
    for (int i = 1; i < n; ++i) {
        if (a[i].x < min_p.x) {
            min_p = a[i];
        } else if (a[i].x == min_p.x && a[i].y < min_p.y) {
            min_p = a[i];
        }
    }
    for (int i = 0; i < n; ++i) {
        a[i] = a[i] - min_p;
    }

    sort(a.begin(), a.end(), [](Vector u, Vector v){
        if (u % v == 0) {
            return u.sqlen() < v.sqlen();
        }
        return u % v > 0;
    });

    Vector rgh = a.back();
    sort(a.begin() + 1, a.end(), [&rgh](Vector u, Vector v) {
        if (u % v == 0) {
            if (rgh % u == 0) {
                return u.sqlen() > v.sqlen();
            }
            return u.sqlen() < v.sqlen();
        }
        return u % v > 0;
    });

    for (Vector p : a) {
        /// cerr << p.x << " " << p.y << endl;
        while (sz >= 2 && (hull[sz - 1] - hull[sz - 2]) % (p - hull[sz - 1]) < 0) {
            cent.push_back(hull.back());
            hull.pop_back();
            --sz;
        }
        hull.push_back(p);
        ++sz;
    }

    bool is_line = true;
    for (int i = 2; i < sz; ++i) {
        if ((hull[i] - hull[0]) % (hull[i] - hull[1]) != 0) {
            is_line = false;
            break;
        }
    }
    if (is_line) {
        cout << "2\n";
        return;
    }
    int ans = hull.size(); /// left part is empty;
    vector<int> hsh(n);
    for (int i = 0; i < n; ++i) {
        hsh[i] = rnd();
    }
    unordered_set<int> opt;
    for (int i = 0; i < (int)cent.size(); ++i) {
        int cur = hsh[i];
        int ind = -1;
        vector<pair<Vector, int>> ev;
        for (int j = 0; j < (int)cent.size(); ++j) {
            if (i == j) continue;
            ev.push_back({cent[j] - cent[i], j});
            ev.push_back({cent[i] - cent[j], j});
        }
        for (int j = 0; j < sz; ++j) {
            ev.push_back({hull[j] - cent[i], j + cent.size()});
        }
        for (int j = 0; j < (int)cent.size(); ++j) {
            if (i == j) continue;
            if (hp(cent[j] - cent[i])) {
                cur ^= hsh[j];
            }
        }
        for (int j = 0; j < sz; ++j) {
            if (!hp(hull[j] - cent[i]) && hp(hull[(j + 1) % sz] - cent[i])) {
                ind = j;
            }
        }
        sort(ev.begin(), ev.end());

        auto operate = [&](int i) {
            if (i >= cent.size()) {
                ind = i - cent.size();
            } else {
                cur ^= hsh[i];
            }
        };

        for (int j = 0; j < (int)ev.size(); ++j) {
            operate(ev[j].second);
            while (j + 1 < (int)ev.size() && ev[j].first % ev[j + 1].first == 0) {
                ++j;
                operate(ev[j].second);
            }
            opt.insert(cur ^ hsh[cent.size() + ind]);
        }
    }
    ans += opt.size();
    cout << ans << "\n";
}

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

    int tst;
    cin >> tst;
    while (tst--) solve();

    return 0;
}