#include<complex>
#include<vector>
#include<iostream>
#include<stack>
#include<cmath>

#define FRONT 0x01
#define RIGHT 0x02
#define BACK 0x04
#define LEFT 0x08
#define OVER 0x10

#define CIRCLE_SAME 0x01
#define CIRCLE_CONTAIN 0x02
#define CIRCLE_NO_CROSS 0x04
#define CIRCLE_ONE_CROSS 0x08
#define CIRCLE_ONE_INSIDE_CROSS 0x10
#define CIRCLE_TWO_CROSS 0x20

#define sc second
#define fr first

#define REP(i,n) for(int i = 0; i < (int)(n); ++i)

using namespace std;

typedef double elem;
typedef complex<elem> point, vec;
typedef pair<point, point> line, seg, pp, hline;

const double eps = 1.0e-8;
const double pi = acos(-1.0);
const double infty = 1e30;
point origin(0.0,0.0);
point base(0,0);

ostream &operator<<(ostream &os, const pair<point,point> &p){
  os << p.fr << "," << p.sc;
  return os;
}

inline elem sq(elem a){ return a*a; }
inline elem cq(elem a){ return a*a*a; }

elem rad(elem deg){ return (deg/180)*pi; }
elem deg(elem rad){ return (rad*180)/pi; }

bool eq(elem a, elem b){ return abs(a-b) < eps; }
bool lt(elem a, elem b){ return !eq(a,b) && a < b; }
bool leq(elem a, elem b){ return eq(a,b) || a < b; }
bool gt(elem a, elem b){ return !eq(a,b) && a > b; }
bool geq(elem a, elem b){ return eq(a,b) || a > b; }
bool ltz(elem a){ return lt( a, 0 ); }
bool gtz(elem a){ return gt( a, 0 ); }
bool eqv(vec a, vec b){ return eq( abs(b-a),0); }
bool is_zv(vec v){ return eq(abs(v),0); }
elem emax(elem a, elem b){ return gt(a,b)?a:b; }
elem emin(elem a, elem b){ return lt(a,b)?a:b; }

// _Iy[^
bool far(point a, point b){ return gtz( abs(b-a) ); }
bool near(point a, point b){ return leq( abs(b-a), 0 ); }
elem dot(vec a, vec b){ return (a.real() * b.real() + a.imag() * b.imag() ); }
elem cross(vec a, vec b){ return ( a.real() * b.imag() - a.imag() * b.real() ); }

// a©çbÜÅvñèÌpxAàpA]ñ]
elem varg(vec a, vec b){
  elem ret=arg(a)-arg(b);
  if(lt(ret,0))ret+=2*pi;
  if(gt(ret,2*pi))ret-=2*pi;
  if(eq(ret,2*pi))ret=0;
  return ret;
}
elem arg(vec a, vec b){ return acos( dot(a,b) / ( abs(a) * abs(b) ) ); }
point rot(point p, elem theta){ return p * polar((elem)1.0, theta); }
point rotdeg(point p, elem deg){ return p * polar((elem)1.0, rad(deg)); }
point proj(line l, point p){
  double t=dot(p-l.first,l.first-l.second)/abs(l.first-l.second);
  return l.first + t*(l.first-l.second);
}
point reflect(line l, point p){ return p+2.0*(proj(l,p)-p); }

// ñ_Ô£A¼üÆ_ÌÅZ£AüªÆ_ÌÅZ£
elem dist(point a, point b){ return abs(a-b); }
elem dist_l(line l, point x){ return abs(cross(l.sc-l.fr,x-l.fr)) / abs(l.sc-l.fr); }
elem dist_h(hline l, point x){
  if( ltz( dot(l.sc-l.fr,x-l.fr) ) ) return abs(x-l.fr);
  return dist_l(l,x);
}
elem dist_seg(seg s, point x)
{
  if( ltz( dot(s.sc-s.fr,x-s.fr) ) ) return abs(x-s.fr);
  if( ltz( dot(s.fr-s.sc,x-s.sc) ) ) return abs(x-s.sc);
  return dist_l(s,x);
}

// PÊxNgA@üxNgAPÊ@üxNg
vec uvec(vec a){ return a / abs(a); }
vec nmr(vec a){ return a * vec(0,-1); }
vec nml(vec a){ return a * vec(0,1); }
vec unmr(vec a){ return uvec( nmr(a) ); }
vec unml(vec a){ return uvec( nml(a) ); }

// CCW oXg¾ªA¸xÉæé
int ccw(point a, point b, point x){
  b -= a;
  x -= a;
  // if( is_zv(b) || is_zv( x ) ) return ERROR;
  if( gtz( cross(b,x) ) ) return LEFT;
  if( ltz( cross(b,x) ) ) return RIGHT;
  if( ltz( dot(b,x) ) ) return BACK;
  if( lt( abs(b), abs(x) ) ) return FRONT;
  return OVER;
}

// üªÌð·»èAºÍ_ÌÝÅßéo[WA»ÌºÍxNg(üªÌ[_Åðíé)
bool intersectedSS(seg a, seg b)
{
  if( ccw(a.fr,a.sc,b.fr)&OVER || ccw(a.fr,a.sc,b.sc)&OVER ) return true;
  return
    ( ccw(a.fr,a.sc,b.fr) | ccw(a.fr,a.sc,b.sc) ) == (LEFT|RIGHT) &&
    ( ccw(b.fr,b.sc,a.fr) | ccw(b.fr,b.sc,a.sc) ) == (LEFT|RIGHT) ;
}
bool intersectedLL(line a, line b){
  return !eq( cross(a.fr-a.sc,b.fr-b.sc), 0.0 );
}

// ð_vZ
point intersectionSS(seg a, seg b)
{
  elem d1 = dist_l(b,a.fr);
  elem d2 = dist_l(b,a.sc);
  return a.fr + ( d1 / (d1 + d2 ) ) * (a.sc-a.fr);
}
point intersectionLL(line a, line b)
{
  vec va = a.sc - a.fr;
  vec vb = b.sc - b.fr;
  return a.fr + va * ( cross(vb, b.fr - a.fr) / cross(vb,va) );
}

// ð·Eð_ê
bool intersectionLL(line a, line b, point &ret){
  if( intersectedLL( a, b ) ){
    ret = intersectionLL( a, b );
    return true;
  }
  return false;
}
bool intersectionLS(line l, seg s, point &ret){
  point tmp;
  if( intersectionLL(l,s,tmp) ){
    if(ccw(s.fr,s.sc,tmp)&OVER){
      ret=tmp;
      return true;
    }
  }
  return false;
}
bool intersectionLH(line l, hline h, point &ret){
  point tmp;
  if( intersectionLL(l,h,tmp) ){
    if(ccw(h.fr,h.sc,tmp)&(OVER|FRONT)){
      ret=tmp;
      return true;
    }
  }
  return false;
}
bool intersectionHS(hline h, seg s, point &ret){
  point tmp;
  if( intersectionLS(h,s,tmp) ){
    if(ccw(h.fr,h.sc,tmp)&(OVER|FRONT)){
      ret=tmp;
      return true;
    }
  }
  return false;
}
bool intersectionHH(hline h, hline k, point &ret){
  point tmp;
  if( intersectionLL(h,k,tmp) ){
    if( ccw(h.fr,h.sc,tmp)&(OVER|FRONT) && ccw(k.fr,k.sc,tmp)&(OVER|FRONT) ){
      ret=tmp;
      return true;
    }
  }
}
bool intersectionSS(seg a, seg b, point &ret){
  if( intersectedSS(a,b) ){
    ret = intersectionSS(a,b);
    return true;
  }
  return false;
}

struct circle{
  point c;
  elem r;
  circle():c(point(0,0)),r(0){}
  circle(point c, elem r):c(c),r(r){}
  bool incircle(point t){
    return leq( abs(t-c), r);
  }
};

bool intersectionCL(circle c, line l, pp &ret){
  vec v(l.second-l.first);
  v = nml( v );
  point intersection;
  if( intersectionLL(l,line(c.c,v+c.c), intersection ) ){
    if( c.incircle( intersection ) ){
      elem k = sqrt( pow(c.r,(elem)2.0) - pow(dist(intersection,c.c),(elem)2.0) );
      vec cr = k * unmr( v );
      vec cl = k * unml( v );
      ret.first = cl + intersection;
      ret.second = cr + intersection;
      return true;
    }
  }
  return false;
}

struct UFO{
  point p;
  elem v;
  elem r;
  bool alive;
  bool reached;

  UFO():p(origin),v(0.0),r(0.0),alive(true),reached(false){}
  UFO(point p,elem v,elem r):p(p),v(v),r(r),alive(true),reached(false){}

  bool shootBy(hline laser, elem R){
    pp ret;
    if( intersectionCL(circle(p,r),laser,ret) ){
      if( ( ccw(laser.fr,laser.sc,ret.fr )&(OVER|FRONT) && gt( abs(ret.fr), R ) ) ||
	  ( ccw(laser.fr,laser.sc,ret.sc )&(OVER|FRONT) && gt( abs(ret.sc), R ) ) ){
	return true;
      }
    }
    return false;
  }

  void progress(elem R){
    point prev = p;
    p = p+v*uvec(origin-p);
    if( ccw(prev,p,origin) & OVER ){
      p = origin;
    }
    if( leq( abs(p), R ) ){
      reached=true;
      alive=false;
    }
  }

};

int main(){
  while(true){
    int ans = 0;
    vector<UFO> ufo;
    elem R;
    int N;

    cin >> R >> N;
    if(R==0&&N==0)break;

    for(int i = 0; i < N; ++i){
      elem x,y,r,v;
      cin >> x >> y >> r >> v;
      ufo.push_back( UFO(point(x,y),v,r) );
    }

    while(true){
      int target=-1;
      elem mindist=infty;

      for(int i = 0; i < ufo.size(); ++i){
	if( ufo[i].alive ){
	  ufo[i].progress(R);
	}
      }
      
      for(int i = 0; i < ufo.size(); ++i){
	if( ufo[i].alive ){
	  elem dist = abs(ufo[i].p);
	  if( gt(dist,R) && lt(dist,mindist) ){
	    mindist=dist;
	    target=i;
	  }
	}
      }

      if( target == -1 )break;
      
      hline laser(origin,ufo[target].p);
      
      for(int i = 0; i < ufo.size(); ++i){
	if( ufo[i].alive ){
	  if( ufo[i].shootBy( laser, R ) ){
	    ufo[i].alive=false;
	    ufo[i].reached=false;
	    //cout << " UFO : " << i << " at " << ufo[i].p << " CRASHED." << endl;
	  }
	}
      }
      //cout << "END OF LASER ATTACK" << endl;
    }

    for(int i = 0; i < ufo.size(); ++i){
      if( ufo[i].reached ) ++ans;
    }
    
    cout << ans << endl;
    
  }
  return 0;
}

Measured memory_bytes: 0