#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <cstdio>
#include <climits>
#include <cassert>
using namespace std;

ifstream fin("squares.txt");
#define cin fin

struct Range;
vector<Range> rs;

struct Pt
{
  int x, y;
};

struct Range
{
  Pt st, ed;
  int d;
};

struct EventPoint
{
  int id;
  bool start;
  const Range& range() const { return rs[id]; }
  const Pt& st() const { return rs[id].st; }
  const Pt& ed() const { return rs[id].ed; }
  const Pt& pt() const { return start ? st() : ed(); }
  int d() const { return rs[id].d; }
};

bool operator<( const Pt& a, const Pt& b )
{
  // a.y/a.x < b.y/b.x
  return a.y*b.x < b.y*a.x;
}

bool operator==( const Pt& a, const Pt& b )
{
  // a.y/a.x == b.y/b.x
  return a.y*b.x == b.y*a.x;
}

bool operator!=( const Pt& a, const Pt& b )
{
  // a.y/a.x != b.y/b.x
  return a.y*b.x != b.y*a.x;
}

bool operator<( const EventPoint& a, const EventPoint& b )
{
  if( a.pt() != b.pt() ) return a.pt() < b.pt();
  if( a.start != b.start ) return a.start < b.start;
  return a.d() < b.d();
}

struct CMP
{
  bool operator()( int i, int j ) const
    {
      return rs[i].d < rs[j].d;
    }
};

int solve()
{
  vector<EventPoint> eps;
  for(int i=0; i!=rs.size(); ++i)
    {
      EventPoint ep_s = {i, true};
      EventPoint ep_e = {i, false};
      eps.push_back( ep_s );
      eps.push_back( ep_e );
    }
  sort( eps.begin(), eps.end() );

  set<int> visible;
  // nearest_first
  set<int,CMP> cur_set;

  for(int i=0,j; i!=eps.size(); i=j)
    {
      // [i,j)
      Pt pos = eps[i].pt();
      for( j=i+1; j!=eps.size(); ++j )
        if( pos != eps[j].pt() )
          break;

      for(int k=i; k!=j; ++k)
        if( eps[k].start )
          cur_set.insert( eps[k].id );
        else
          cur_set.erase( eps[k].id );

      if( !cur_set.empty() )
        visible.insert( *cur_set.begin() );
    }

  return visible.size();
}

int main()
{
  if(!fin) return -1;

  for(int N; cin>>N, N; )
    {
      rs.clear();
      while( N-- )
        {
          int x, y, l;
          cin >> x >> y >> l;
          Pt st={x+l,y}, ed={x,y+l};
          Range r = {st, ed, x+y+l};
          rs.push_back(r);
        }
      cout << solve() << endl;
    }
  return 0;
}