#include<iostream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iomanip>
#include<cassert>
#include<cstdlib>
#include<complex>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)
#define EPS (1e-8)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1 
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define MAX 110
using namespace std;

// template
class Point
{
  public:
  long double x,y;

  Point(long double x = -inf,long double y = -inf): x(x),y(y){}

  Point operator + (Point p ){return Point(x+p.x,y+p.y);}
  Point operator - (Point p){return Point(x-p.x,y-p.y);}
  Point operator * (long double a){return Point(a*x,a*y);}
  Point operator / (long double a){return Point(x/a,y/a);}

  bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:y<p.y; }

};

struct Segment
{
  Point p1,p2;
  Segment(Point p1 = Point(-1,-1),Point p2 = Point(-1,-1)):p1(p1),p2(p2){}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;

double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }

double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }

double norm(Point a){ return a.x*a.x+a.y*a.y; }

bool point_equals(Point a,Point b){ return equals(a.x,b.x) && equals(a.y,b.y); }

Point rotate(Point a,double rad){ return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y); }

double toRad(double agl){ return agl*M_PI/180.0; }

int ccw(Point p0,Point p1,Point p2)
{
  Point a = p1-p0;
  Point b = p2-p0;
  if(cross(a,b) > EPS)return COUNTER_CLOCKWISE;
  if(cross(a,b) < -EPS)return CLOCKWISE;
  if(dot(a,b) < -EPS)return ONLINE_BACK;
  if(norm(a) < norm(b))return ONLINE_FRONT;
  return ON_SEGMENT;
}

double abs(Point a){ return sqrt(norm(a)); }

double getDistanceLP(Line s,Point p){ return abs(cross(s.p2-s.p1,p-s.p1))/abs(s.p2-s.p1); }

double getDistanceSP(Segment s,Point p)
{
  if(dot(s.p2-s.p1,p-s.p1) < 0.0)return abs(p-s.p1);
  if(dot(s.p1-s.p2,p-s.p2) < 0.0)return abs(p-s.p2);
  return getDistanceLP(s,p);
}

//cross product of pq and pr
double cross3p(Point p,Point q,Point r)
{
  return (r.x-q.x) * (p.y -q.y) - (r.y - q.y) * (p.x - q.x);
}
  
//returns true if point r is on the same line as the line pq
bool collinear(Point p,Point q,Point r)
{
  return fabs(cross3p(p,q,r)) < EPS;
}
  
//returns true if point t is on the left side of line pq
bool ccwtest(Point p,Point q,Point r)
{
  return cross3p(p,q,r) > 0;//can be modified to accept collinear points
}
 
bool onSegment(Point p,Point q,Point r)
{
  return collinear(p,q,r) && equals(sqrt(pow(p.x-r.x,2)+pow(p.y-r.y,2)) + sqrt(pow(r.x-q.x,2) + pow(r.y-q.y,2) ),sqrt(pow(p.x-q.x,2)+pow(p.y-q.y,2)) ) ;
}


//--------------------------------------------------------------------------

struct UFO
{
  Point p;
  long double r,v;
  UFO(Point p=Point(),long double r=-inf,long double v=-inf):p(p),r(r),v(v){}
};

long double R;
int N;
UFO ufo[MAX];
bool alive[MAX];

int main()
{
  int rx;
  while(cin >> rx >> N,rx|N)
    {
      R = (long double)rx;
      rep(i,N)
	{
	  cin >> ufo[i].p.x >> ufo[i].p.y >> ufo[i].r >> ufo[i].v;
	  alive[i] = true;
	}

      int pass = 0;	

      while(true)
	{
	  int nearest = -inf;
	  rep(i,N)
	    {
	      if(!alive[i])continue;
	      Point e = ufo[i].p/abs(ufo[i].p);
	      Point next = ufo[i].p - e*ufo[i].v;
	      long double dist_next = abs(next);
	      if( onSegment(ufo[i].p,next,Point(0,0)) || equals(dist_next,R) || dist_next < R  || equals(abs(ufo[i].p),R) || abs(ufo[i].p) < R)
		{
		  alive[i] = false;
		  pass++;
		  continue;
		}
	      ufo[i].p = next;
	      if(nearest == -inf)nearest = i;
	      else
		{
		  long double d1 = abs(ufo[nearest].p);
		  long double d2 = abs(ufo[i].p);
		  if(!equals(d1,d2) && d1 > d2)nearest = i;
		}
	    }

	  if(nearest == -inf)break;

	  rep(i,N)
	    {
	      if(!alive[i])continue;
	      assert(!equals(abs(ufo[i].p),R) && abs(ufo[i].p) > R);
	    }

	  Vector e = ufo[nearest].p/abs(ufo[nearest].p);

	  Segment seg = Segment(e*R,e*10000000.0);
	  rep(i,N)
	    {
	      if(!alive[i])continue;
	      //assert(abs(e) > abs(ufo[i].p));
	      long double dist = getDistanceSP(seg,ufo[i].p);
	      if(equals(dist,ufo[i].r) || dist < ufo[i].r)
		{
		  alive[i] = false;
		  continue;
		}
	    }

	}
      cout << pass << endl;
    }
  return 0;
} 

Measured memory_bytes: 1240