#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

struct Pt
{
	int x, y;
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
};

LL sq(const Pt& p)
{
	return (LL)p.x * p.x + (LL)p.y * p.y;
}

int sgn(LL x)
{
	return (0 < x) - (x < 0);
}

LL dot(const Pt& p, const Pt& q)
{
	return (LL)p.x * p.x + (LL)p.y * p.y;
}

LL cross(const Pt& p, const Pt& q)
{
	return (LL)p.x * q.y - (LL)p.y * q.x;
}

LL orient(const Pt& p, const Pt& q, const Pt& r)
{
	return cross(q - p, r - p);
}

bool half(const Pt& p)
{
	assert(sgn(p.x) != 0 || sgn(p.y) != 0);
	return sgn(p.y) == -1 ||
		(sgn(p.y) == 0 && sgn(p.x) == -1);
}

void polarSortAround(const Pt& o, vector<pair<Pt, int>>& v)
{
	sort(ALL(v), [o](pair<Pt, int> pp, pair<Pt, int> qq)
	{
		Pt p = pp.F - o;
		Pt q = qq.F - o;
		bool hp = half(p), hq = half(q);
		if (hp != hq)
			return hp < hq;
		int s = sgn(cross(p, q));
		if (s != 0)
			return s == 1;
		return sq(p) < sq(q);
	});
}

bool inDisk(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(dot(a - p, b - p)) <= 0;
}

bool onSegment(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(orient(a, b, p)) == 0 && inDisk(a, b, p);
}

bool inConvexPolygon(const vector<Pt>& v, const Pt& a)
{
	assert(SZ(v) >= 2);
	if (SZ(v) == 2)
		return onSegment(v[0], v[1], a);
	if (sgn(orient(v.back(), v[0], a)) < 0
		|| sgn(orient(v[0], v[1], a)) < 0)
		return false;
	int i = lower_bound(v.begin() + 2, v.end(), a,
		[&](const Pt& p, const Pt& q)
		{
			return sgn(orient(v[0], p, q)) > 0;
		}) - v.begin();
	return sgn(orient(v[i - 1], v[i], a)) >= 0;
}

vector<Pt> convexHull(vector<Pt> v)
{
	if (SZ(v) <= 1)
		return v;
	sort(ALL(v), [](const Pt& p, const Pt& q)
	{
		int dx = sgn(p.x - q.x);
		if (dx != 0)
			return dx < 0;
		return sgn(p.y - q.y) < 0;
	});
	vector<Pt> lower, upper;
	for (const Pt& p : v)
	{
		while (SZ(lower) > 1
			&& sgn(orient(lower[SZ(lower) - 2], lower.back(), p)) <= 0)
			lower.pop_back();
		while (SZ(upper) > 1
			&& sgn(orient(upper[SZ(upper) - 2], upper.back(), p)) >= 0)
			upper.pop_back();
		lower.PB(p);
		upper.PB(p);
	}
	reverse(ALL(upper));
	lower.insert(lower.end(), next(upper.begin()), prev(upper.end()));
	return lower;
}

PII tangetsToConvexPolygon(const vector<Pt>& v, const Pt& p)
{
	int n = SZ(v), i = 0;
	if (n == 2)
		return {0, 1};
	while (sgn(orient(p, v[i], v[(i + 1) % n]))
		* sgn(orient(p, v[i], v[(i + n - 1) % n])) > 0)
		i++;
	int s1 = 1, s2 = -1;
	if (sgn(orient(p, v[i], v[(i + 1) % n])) == s1
		|| sgn(orient(p, v[i], v[(i + n - 1) % n])) == s2)
		swap(s1, s2);
	PII res;
	int l = i, r = i + n - 1;
	while (r - l > 1)
	{
		int m = (l + r) / 2;
		if (sgn(orient(p, v[i], v[m % n])) != s1
			&& sgn(orient(p, v[m % n], v[(m + 1) % n])) != s1)
			l = m;
		else
			r = m;
	}
	res.F = r % n;
	l = i;
	r = i + n - 1;
	while (r - l > 1)
	{
		int m = (l + r) / 2;
		if (sgn(orient(p, v[i], v[m % n])) == s2
			|| sgn(orient(p, v[m % n], v[(m + 1) % n])) != s2)
			l = m;
		else
			r = m;
	}
	res.S = r % n;
	return res;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin >> n;
	vector<Pt> v[2];
	FOR(i, 0, n)
	{
		Pt p;
		int c;
		cin >> p.x >> p.y >> c;
		v[c].PB(p);
	}
	vector<Pt> hull = convexHull(v[1]);
	if (SZ(hull) == 1)
	{
		int ans = SZ(v[1]);
		if (ans == 1)
		{
			cout << "1\n";
			return 0;
		}
		for (const Pt& p : v[0])
		{
			if (p.x == hull[0].x && p.y == hull[0].y)
				ans++;
		}
		cout << ans << "\n";
		return 0;
	}
	int cntFalseInside = 0;
	vector<pair<Pt, int>> events;
	int cur = 0;
	for (const Pt& p : v[0])
	{
		if (inConvexPolygon(hull, p))
			cntFalseInside++;
		else
		{
			auto [i1, i2] = tangetsToConvexPolygon(hull, p);
			// assert(sgn(orient(p, hull[i1], hull[i2])) != 0);
			if (sgn(orient(p, hull[i1], hull[i2])) < 0)
				swap(i1, i2);
			events.PB({hull[i1] - p, 1});
			events.PB({hull[i2] - p, -1});
			events.PB({p - hull[i1], 1});
			events.PB({p - hull[i2], -1});
			if ((hull[i1] - p).y <= 0 && (hull[i2] - p).y >= 0)
				cur++;
			else if ((p - hull[i1]).y <= 0 && (p - hull[i2]).y >= 0)
				cur++;
		}
	}
	polarSortAround({0, 0}, events);
	int ans = cur;
	for (int i = 0; i < SZ(events); )
	{
		int j = i;
		while (j < SZ(events) && sgn(cross(events[i].F, events[j].F)) == 0 && sgn(dot(events[i].F, events[j].F)) > 0)
		{
			if (!(events[j].F.x > 0 && events[j].F.y == 0 && events[j].S == 1))
				cur += events[j].S;
			j++;
		}
		ans = min(ans, cur);
		i = j;		
	}
	cout << ans + SZ(v[1]) + cntFalseInside << "\n";
	return 0;
}