#define SCANNER_H_ 1
#include<stdio.h>
#include<stdlib.h>
class Scanner {
private:static const int BUFFER_SIZE=10000;char buff[BUFFER_SIZE];int buffPos,buffLim;
public:Scanner(){
    buffLim=fread(buff,1,BUFFER_SIZE,stdin);
    buffPos=0;
}
private:
inline void flushBuff(){
    buffLim=fread(buff,1,BUFFER_SIZE,stdin);
    if(!buffLim)buff[buffLim++]=10;
    buffPos=0;
}
inline bool isWS(char t){return t<33;}
inline bool isDig(char t){return t>47&&t<58;}
void nextPos(){
    ++buffPos;
    if(buffPos==buffLim)flushBuff();
}
#define getChar() buff[buffPos]
public:
inline char getchar(){
    char ch=getChar();
    nextPos();
    return ch;
}
inline void next(char*s){
    while(isWS(getChar()))nextPos();
    while(!isWS(getchar())){
        *s=getChar();
        ++s;
        nextPos();
    }
    *s=0;
}
inline void nextLine(char*s){
    while(getChar()!=10)nextPos();
    if(getChar()==10)nextPos();
    while(getChar()!='\n'){
        *s=getChar();
        ++s,++buffPos;
    }
    *s=0;
}
inline int nextInt(){
    while(!isDig(getChar())&&getChar()!=45)nextPos();
    int sign=(getChar()==45)?nextPos(),-1:1,res=0;
    while(isDig(getChar()))res=res*10+(getChar()^48),nextPos();
    return res*sign;
}
inline long long nextLong(){
    while(!isDig(getChar())&&getChar()!=45)nextPos();
    long long sign=(getChar()==45)?nextPos(),-1:1,res=0;
    while(isDig(getChar()))res=res*10+(getChar()^48);
    return res*sign;
}
inline int n(){
    while(getChar()<48||getChar()>57){
        ++buffPos;
        if(buffPos==buffLim)flushBuff();
    }
    int res=0;
    while(getChar()>47&&getChar()<58){
        res=res*10+(getChar()^48),++buffPos;
        if(buffPos==buffLim)flushBuff();
    }
    return res;
}
inline long long nl(){
    while(getChar()<48||getChar()>57){
        ++buffPos;
        if(buffPos==buffLim)flushBuff();
    }
    long long res=0;
    while(getChar()>47&&getChar()<58){
        res=res*10+(getChar()^48),++buffPos;
        if(buffPos==buffLim)flushBuff();
    }
    return res;
}
inline long long nlm(const int MOD){
    while(getChar()<48||getChar()>57){
        ++buffPos;
        if(buffPos==buffLim)flushBuff();
    }
    long long res=0;
    while(getChar()>47&&getChar()<58){
        res=(res*10+(getChar()^48))%MOD,++buffPos;
        if(buffPos==buffLim)flushBuff();
    }
    return res;
}
inline double nextDouble(){
    while(isWS(getChar()))nextPos();
    int sign=(getChar()==45)?nextPos(),-1:1;
    double res=0;
    while(isDig(getChar()))res=res*10+(getChar()^48),nextPos();
    if(getChar()=='.'){
        nextPos();
        double ep=1;
        while(isDig(getChar()))ep*=0.1,res+=ep*(getChar()^48),nextPos();
    }
    return sign*res;
}
inline char nextChar(){
    while(isWS(getChar()))nextPos();
    char res=getChar();
    nextPos();
    return res;
}
#undef getChar
}sc;
#define LOG_H_ 1
#define see(...)
#define ses(...)
#define slog(format,...)
template<class _Type>void LogArray(_Type a[],int n){}
#define LOOP_H_ 1
#define repe(a,b) for(int a=0;a<(int)b.size();++a)
#define rep(i,n) for(int i=0;i<n;++i)
#define repa(i,n) for(int i=1;i<=n;++i)
#define repi(i,a,b) for(int i=a;i<=b;++i)
#define repb(i,a,b) for(int i=a;i>=b;--i)
#define BASE_H_ 1
template<class T>inline bool checkMin(T&a,T b){return(a>b?a=b,1:0);}
template<class T>inline bool checkMax(T&a,T b){return(a<b?a=b,1:0);}
#include<bits/stdc++.h>
#define _BODY_MAIN 1
#ifndef CUSTOM_MAIN
void preInit();
void init();
void solve();
int32_t main(){
    init();
    solve();
    return 0;
}
#endif
#define GEOMETRY_H_EPS 1e-8
#define double long double
#define GEOMETRY_H_ 1
#include<cmath>
#include<algorithm>
#include<vector>
#include<iostream>
#define M_PI 3.14159265358979323846
namespace Temps{
namespace Compare{
constexpr double eps=1e-8;
inline void testZero(double&a){if(std::abs(a)<=eps)a=0;}
inline bool equal(double a,double b){return std::abs(b-a)<=eps;}
inline bool notEqual(double a,double b){return std::abs(b-a)>eps;}
inline bool less(double a,double b){return a+eps<b;}
inline bool less_equal(double a,double b){return a<=b+eps;}
inline bool greater(double a,double b){return a>b+eps;}
inline bool greater_equal(double a,double b){return a+eps>=b;}
inline bool in_interval(double u,double l,double r){
    if(l>r)std::swap(l,r);
    return greater_equal(u,l)&&less_equal(u,r);
}
inline bool in_interval_open(double u,double l,double r){
    if(l>r)std::swap(l,r);
    return greater(u,l)&&less(u,r);
}
};
struct Point;
struct Circle;
struct Vector;
struct Line;
struct Segment;
struct Point{
    double x,y;
    explicit constexpr Point(double x=0,double y=0):x(x),y(y){}
    inline double distance(const Point&B)const{return __builtin_sqrt((x-B.x)*(x-B.x)+(y-B.y)*(y-B.y));}
    inline bool operator==(const Point&B)const{return Compare::equal(x,B.x)&&Compare::equal(y,B.y);}
    inline bool isnop()const{return x==INFINITY&&y==INFINITY;}
    inline Point add(const Vector&b)const;
    inline Point mid(const Point&b)const{return Point((x+b.x)/2,(y+b.y)/2);}
    inline bool operator<(const Point&b)const{return x==b.x?y<b.y:x<b.x;}
    inline double getAngle()const{return atan2(y,x);}
    inline friend std::ostream&operator<<(std::ostream&os,const Point&b){
        os<<"("<<b.x<<","<<b.y<<")";
        return os;
    }
};
struct Vector{
    double x,y;
    explicit constexpr Vector(double x=0,double y=0):x(x),y(y){}
    explicit constexpr Vector(const Point&a,const Point&b):x(b.x-a.x),y(b.y-a.y){}
    explicit constexpr Vector(const Point&a):x(a.x),y(a.y){}
    explicit constexpr Vector(const Segment&a);
    inline double cross(const Vector&B)const{return x*B.y-y*B.x;}
    inline Vector mul(double p)const{return Vector(x*p,y*p);}
    inline double mul(const Vector&b)const{return x*b.x+y*b.y;}
    inline double getk()const{return y/x;}
    inline double length()const{return __builtin_sqrt(x*x+y*y);}
    inline Vector rotater()const{return Vector(y,-x);}
    inline Vector rotatel()const{return Vector(-y,x);}
    inline Vector rotate(double _sin,double _cos)const{return Vector(x*_cos-y*_sin,x*_sin+y*_cos);}
    inline Vector rotate(double _ang)const{return rotate(std::sin(_ang),std::cos(_ang));}
    inline Vector zoom(double newLen=1)const{
        double factor=newLen/length();
        return Vector(x*factor,y*factor);
    }
    inline double arg(const Vector&b)const{return std::acos(mul(b)/(length()*b.length()));}
    inline double arg()const{return std::atan2(y,x);}
};
inline Point Point::add(const Vector&b)const{return Point(x+b.x,y+b.y);}
static constexpr Point nop=Point(INFINITY,INFINITY);
struct Line{
    Point origin;
    Vector slope;
    explicit constexpr Line()=default;
    explicit constexpr Line(const Point&origin,const Vector&slope):origin(origin),slope(slope){}
    explicit constexpr Line(const Point&a,const Point&b):origin(a),slope(Vector(a,b)){}
    explicit constexpr Line(double k,double b):origin(Point(0,b)),slope(Vector(1,k)){}
    explicit constexpr Line(const Segment&b);
    inline bool cover(Point x)const{return Compare::equal(slope.cross(Vector(origin,x)),0);}
    inline Point cross(const Line&b)const{
        double _x=Vector(origin,b.origin).cross(b.slope),
               _y=slope.cross(b.slope);
        if(Compare::equal(_y,0))return nop;
        _x/=_y;return origin.add(slope.mul(_x));
    }
    inline double getk()const{return slope.getk();}
    inline double getb()const{return origin.y+(-origin.x)*getk();}
    inline double distance(const Point&b)const{return cross(Line(b,slope.rotater())).distance(b);}
    inline double shadowLength(const Point&b)const{
        Point shadow=cross(Line(b,slope.rotater()));
        if(Compare::equal(slope.x,0))return(shadow.y-origin.y)/slope.y;
        return(shadow.x-origin.x)/slope.x;
    }
};
struct Segment{
    Point a,b;
    explicit Segment()=default;
    explicit Segment(Point a,Point b):a(a),b(b){}
    bool cover(Point x){
        if(!Compare::in_interval(x.x,a.x,b.x)||!Compare::in_interval(x.y,a.y,b.y))return 0;
        return Line(a,b).cover(x);
    }
    inline Line getPlumb()const{return Line(a.mid(b),Vector(a,b).rotater());}
    inline Point mid()const{return a.mid(b);}
    inline double length()const{return Vector(a,b).length();}
    inline bool isCross(const Segment&t)const{
        Point c=Line(*this).cross(Line(t));
        if(c.isnop())return 0;
        return Compare::in_interval(c.x,a.x,b.x)&&Compare::in_interval(c.y,a.y,b.y)&&Compare::in_interval(c.x,t.a.x,t.b.x)&&Compare::in_interval(c.y,t.a.y,t.b.y);
    }
    inline bool isCross_open(const Segment&t)const{
        Point c=Line(*this).cross(Line(t));
        if(c.isnop())return 0;
        return Compare::in_interval_open(c.x,a.x,b.x)&&Compare::in_interval_open(c.y,a.y,b.y)&&Compare::in_interval_open(c.x,t.a.x,t.b.x)&&Compare::in_interval_open(c.y,t.a.y,t.b.y);
    }
};
constexpr Line::Line(const Segment&b):origin(b.a),slope(Vector(b.a,b.b)){}
constexpr Vector::Vector(const Segment&a):x(a.b.x-a.a.x),y(a.b.y-a.a.y){}
enum CCW_STATE_T{CCW_CCW,CCW_CW,CCW_BAC,CCW_ABC,CCW_UK};
CCW_STATE_T getCCW(const Point&a,const Point&b,const Point&c){
    Vector vb(a,b),vc(a,c);
    double cross=vb.cross(vc);
    if(Compare::greater(cross,0))return CCW_CCW;
    if(Compare::less(cross,0))return CCW_CW;
    double dot=vb.mul(vc);
    if(Compare::less(dot,0))return CCW_BAC;
    if(Compare::greater(dot,0))return CCW_ABC;
    return CCW_UK;
}
typedef std::vector<Point> Polygon;
Polygon getConvex(Polygon ps){
    std::sort(ps.begin(),ps.end());
    ps.erase(std::unique(ps.begin(),ps.end()),ps.end());
    if(ps.size()<3)return ps;
    Polygon res;
    for(Point p:ps){
        while(res.size()>1){
            Point&a=res[res.size()-2],&b=res.back();
            if(Compare::less_equal(Vector(b,p).cross(Vector(b,a)),0))break;
            res.pop_back();
        }
        res.push_back(p);
    }
    res.pop_back();
    std::size_t osize=res.size();
    std::reverse(ps.begin(),ps.end());
    for(Point p:ps){
        while(res.size()-osize>1){
            Point&a=res[res.size()-2],&b=res.back();
            if(Compare::less_equal(Vector(b,p).cross(Vector(b,a)),0))break;
            res.pop_back();
        }
        res.push_back(p);
    }
    res.pop_back();
    return res;
}
double getPerimeter(const Polygon ps){
    std::size_t sz=ps.size();
    double ans=0;
    for(std::size_t i=0;i<sz;++i)ans+=ps[i].distance(ps[(i+1)%sz]);
    return ans;
}
struct Circle{
    Point o;double r;
    Circle()=default;
    explicit constexpr Circle(const Point&o,double r):o(o),r(r){}
    explicit Circle(const Point&a,const Point&b,const Point&c):o(Segment(a,b).getPlumb().cross(Segment(b,c).getPlumb())),r(o.distance(a)){}
    inline bool cover(const Point&p)const{return Compare::less_equal(o.distance(p),r);}
    inline double perimeter()const{return 2*M_PI*r;}
    inline Point getTangent(const Point&p)const{
        double d=o.distance(p),_cos_r=r/d,_sin_r=__builtin_sqrt(1-_cos_r*_cos_r);
        Vector o_p=Vector(o,p).zoom(r);
        return o.add(o_p.rotate(_sin_r,_cos_r));
    }
    inline Segment getTangentO(const Circle&c)const{
        if(r<c.r)return c.getTangentO(*this);
        double _cos_r=(r-c.r)/o.distance(c.o),_sin_r=__builtin_sqrt(1-_cos_r*_cos_r);
        Vector dv(o,c.o);
        return Segment(o.add(dv.zoom(r).rotate(_sin_r,_cos_r)),c.o.add(dv.zoom(c.r).rotate(_sin_r,_cos_r)));
    }
};
}
using namespace Temps;
Polygon p0,p1;
int n;
bool GET_DATA=0;
inline int getMp(const Polygon&b){return std::max_element(b.begin(),b.end())-b.begin();}
bool PolygonCover(const Polygon&p,const Point&o,int pm=-1){
    if(p.size()==1)return p[0]==o;
    if(p.size()==2)return Segment(p[0],p[1]).cover(o);
    if(pm==-1)pm=getMp(p);
    if(o.x<p[0].x||o.x>p[pm].x)return 0;
    int up_id=std::upper_bound(p.begin(),p.begin()+pm,o,[](const Point&a,const Point&b){return a.x<b.x;})-p.begin();
    if(Compare::greater(Vector(p[up_id-1],p[up_id]).cross(Vector(p[up_id-1],o)),0))return 0;
    int lo_id=std::upper_bound(p.begin()+pm,p.end(),o,[](const Point&a,const Point&b){return a.x>b.x;})-p.begin();
    if(Compare::greater(Vector(p[lo_id-1],p[lo_id%p.size()]).cross(Vector(p[lo_id-1],o)),0))return 0;
    return 1;
}
Point PolygonTangent(const Polygon&p,const Point&o){
    int k=0,sz=p.size();
    for(int D=(1<<21);D;D>>=1){
        if(D>1&&D*2>sz)continue;
        int b=(k-3*D+4*sz)%sz;
        for(int _=0;_<6;++_){
            Vector v0(o,p[b]),v1(o,p[(b+D)%sz]),v2(o,p[(b+D+D)%sz]);
            if(Compare::less(v0.cross(v1),0)&&Compare::greater_equal(v1.cross(v2),0))k=(b+D)%sz;
            (b+=D)%=sz;
        }
    }
    return p[k];
}
Point PolygonTangent2(const Polygon&p,const Point&o){
    int k=0,sz=p.size();
    for(int D=(1<<21);D;D>>=1){
        if(D>1&&D*2>sz)continue;
        int b=(k-2*D+4*sz)%sz;
        for(int _=0;_<4;++_){
            Vector v0(o,p[b]),v1(o,p[(b+D)%sz]),v2(o,p[(b+D+D)%sz]);
            if(Compare::greater_equal(v0.cross(v1),0)&&Compare::less(v1.cross(v2),0))k=(b+D)%sz;
            (b+=D)%=sz;
        }
    }
    return p[k];
}
constexpr Point o(0,0);
constexpr double rotate_ang=6.1;
void preInit(){}
void init(){
    n=sc.n();
    for(int i=0;i<n;++i){
        int x=sc.nextInt(),y=sc.nextInt(),b=sc.nextInt();
        Point p(x,y);
        p=o.add(Vector(o,p).rotate(rotate_ang));
        if(i==0&&x==8980)GET_DATA=1;
        if(!b)p0.push_back(p);
        else p1.push_back(p);
    }
}
void solve(){
    if(!p1.size()){puts("0");return;}
    if(p1.size()==1){puts("1");return;}
    p1=getConvex(p1);
    int mp=getMp(p1);
    {
        std::vector<Point>outer_p0;
        for(Point&p:p0)if(!PolygonCover(p1,p,mp))outer_p0.push_back(p);
        p0=std::move(outer_p0);
    }
    std::vector<std::pair<double,int>>G;
    {
        for(Point&p:p0){
            double A=Vector(PolygonTangent(p1,p),p).arg(),B=Vector(PolygonTangent2(p1,p),p).arg();
            if(Compare::less(B,A))B+=2*M_PI;
            A-=Compare::eps;B+=Compare::eps;
            G.push_back(std::make_pair(A+M_PI,-1));
            G.push_back(std::make_pair(B,1));
        }
        int G_len=G.size();
        for(int i=0;i<G_len;++i){
            std::pair<double,int>p=G[i];
            G.push_back(std::make_pair(p.first+1*M_PI,p.second));
            G.push_back(std::make_pair(p.first+2*M_PI,p.second));
            G.push_back(std::make_pair(p.first+3*M_PI,p.second));
        }
    }
    int max_outer=0;
    {
        std::sort(G.begin(),G.end());
        int cur=0;
        for(auto&p:G)cur+=p.second,checkMax(max_outer,cur);
    }
    printf("%d",n-max_outer);
}