from math import sqrt,fabs,ceil,floor,pow,exp,log,sin,cos,tan,asin,acos,atan,atan2,pi



eps=1e-10
inf=float("inf")

class Angle:	#angle. kaku.
	def __init__(self,th):
		self.th = float(th)%(2*pi)
	def __float__(self):
		return self.th
	def __eq__(self,other):
		return abs(float(self)-float(other))<eps or abs(abs(float(self)-float(other))-2*pi)<eps
	def isParaWith(self,other):
		return self==other or self==other+pi
	def __add__(self,other):
		return Angle( (float(self) + float(other)) % (2*pi) )
	def __sub__(self,other):
		return Angle( (float(self) - float(other)) % (2*pi) )
	def __mul__(self,c):
		return Angle( (float(self) * c) % (2*pi) )
	def __rmul__(self,c):
		return Angle( (float(self) * c) % (2*pi) )
	def __div__(self,c):
		return Angle( (float(self) / c) % (2*pi) )
	def __repr__(self):
		return "Angle("+str(float(self))+")"

class Vector:	#point, vector. ten, bekutoru.
	def __init__(self,x=None,y=None,d=None,th=None):
		if not(x is None) and not(y is None):
			self.setXY(x,y)
		if not(d is None) and not(th is None):
			self.setDTh(d, th)
	def setXY(self,x,y):
		self.x=float(x);
		self.y=float(y);
		self.calcFromXY()
	def setDTh(self,d,th):
		self.d=float(d)
		self.th=Angle(th)
		self.calcFromDTh()
	def calcFromXY(self):
		self.d=sqrt(self.x**2+self.y**2)
		self.th=Angle(atan2(self.y,self.x))
	def calcFromDTh(self):
		self.x=self.d*cos(self.th)
		self.y=self.d*sin(self.th)
	def e(self):
		return self/self.d
	def __eq__(self,other):
		return fabs(self.x-other.x)<eps and fabs(self.y-other.y)<eps
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,other):
		return Vector(self.x+other.x, self.y+other.y)
	def __sub__(self,other):
		return Vector(self.x-other.x, self.y-other.y)
	def __neg__(self):
		return Vector(-self.x, -self.y)
	def __mul__(self,c):
		return Vector(self.x*c, self.y*c)
	def __rmul__(self,c):
		return Vector(self.x*c, self.y*c)
	def __div__(self,c):
		return Vector(self.x/c, self.y/c)
	def __abs__(self):
		return self.d
	def rotated(self,th):
		v=Vector(d=self.d, th=self.th+th)
		return v
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def inprod(self,other):
		return self.x*other.x+self.y*other.y
	def outprod(self,other):
		return self.x*other.y-self.y*other.x
	def isOn(self,obj):
		if isinstance(obj,DirSegLine) or isinstance(obj,SegLine):
			return obj.ap==self or obj.bp==self or (obj.th==(self-obj.ap).th and obj.th==(obj.bp-self).th)
		if isinstance(obj,HalfLine):
			return obj.ap==self or obj.th==(self-obj.ap).th
		if isinstance(obj,Line):
			return obj.th==(self-obj.ap).th or obj.th==(obj.bp-self).th
		if isinstance(obj,Circle):
			return abs(abs(self-obj.p)-obj.d)<eps
	def isIn(self,obj):
		if isinstance(obj,Circle):
			return abs(self-obj.p)<obj.d
	def isOut(self,obj):
		if isinstance(obj,Circle):
			return abs(self-obj.p)>obj.d
	def __repr__(self):
		return "Vector("+str(self.x)+", "+str(self.y)+")"

Point=Vector

class DirSegLine:	#directed line segment. yuukou senbun.
	def __init__(self,ap=None,bp=None,dv=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
	def setApBp(self,ap,bp):
		self.ap=ap
		self.bp=bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.d = abs(self.dv)
		self.th = self.dv.th
	def __eq__(self,other):
		return self.ap==other.ap and self.bp==other.bp
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return DirSegLine(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return DirSegLine(self.ap-v, self.bp-v)
	def __abs__(self):
		return self.d
	def rotated(self,th):
		return DirSegLine(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "DirSegLine(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class SegLine:	#line segmeny. senbun.
	def __init__(self,ap=None,bp=None,dv=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
	def setApBp(self,ap,bp):
		self.ap=ap
		self.bp=bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.d = abs(self.dv)
		self.th = self.dv.th
	def __eq__(self,other):
		return (self.ap==other.ap and self.bp==other.bp) or (self.ap==other.bp and self.bp==other.ap)
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return SegLine(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return SegLine(self.ap-v, self.bp-v)
	def __abs__(self):
		return self.d
	def rotated(self,th):
		return SegLine(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "SegLine(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class HalfLine:
	def __init__(self,ap=None,bp=None,dv=None,th=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
		if not(ap is None) and not(th is None): self.setApBp(ap, ap+Vector(d=1,th=th))
	def setApBp(self,ap,bp):
		self.ap=ap
		self.bp=bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.th = self.dv.th
	def __eq__(self,other):
		return self.ap==other.ap and self.th==other.th
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return HalfLine(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return HalfLine(self.ap-v, self.bp-v)
	def rotated(self,th):
		return HalfLine(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "HalfLine(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class Line:
	def __init__(self,ap=None,bp=None,dv=None,th=None):
		if not(ap is None) and not(bp is None): self.setApBp(ap, bp)
		if not(ap is None) and not(dv is None): self.setApBp(ap, ap+dv)
		if not(bp is None) and not(dv is None): self.setApBp(bp-dv, bp)
		if not(ap is None) and not(th is None): self.setApBp(ap, ap+Vector(d=1,th=th))
		if not(bp is None) and not(th is None): self.setApBp(bp-Vector(d=1,th=th), bp)
	def setApBp(self,ap,bp):
		self.ap=ap
		self.bp=bp
		self.calcFromApBp()
	def calcFromApBp(self):
		self.dv = self.bp - self.ap
		self.th = self.dv.th
	def __eq__(self,other):
		#return ( self.ap==other.ap or self.ap==other.bp or (self.ap-other.ap).isParaWith(other.dv) )	\
		#	and( self.bp==other.ap or self.bp==other.bp or (self.bp-other.bp).isParaWith(other.dv) )
		return self.ap.isOn(other) and self.bp.isOn(other)
	def isParaWith(self,other):
		return self.th.isParaWith(other.th)
	def __add__(self,v):
		return Line(self.ap+v, self.bp+v)
	def __sub__(self,v):
		return Line(self.ap-v, self.bp-v)
	def rotated(self,th):
		return Line(self.ap.rotated(th), self.bp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "Line(ap="+str(self.ap)+", bp="+str(self.bp)+")"

class Circle:
	def __init__(self,p,d):
		self.setPD(p,d)
	def setPD(self,p,d):
		self.p=p
		self.d=float(d)
	def __eq__(self,other):
		return self.p==other.p and abs(self.d-other.d)<eps
	def __add__(self,v):
		return Circle(self.p+v, self.d)
	def __sub__(self,v):
		return Circle(self.p-v, self.d)
	def rotated(self,th):
		return Circle(self.p.rotated(th), self.d)
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def __repr__(self):
		return "Circle(p="+str(self.ap)+", d="+str(self.d)+")"

class Triangle:
	def __init__(self,ap,bp,cp):
		self.setApBpCp(ap,bp,cp)
	def setApBpCp(self,ap,bp,cp):
		self.ap=ap
		self.bp=bp
		self.cp=cp
		self.calcFromApBpCp(ap, bp, cp)
	def calcFromApBpCp(self,ap,bp,cp):
		self.ae=SegLine(bp,cp)
		self.be=SegLine(cp,ap)
		self.ce=SegLine(ap,bp)
	def __eq__(self,other):
		return (self.ap==other.ap and self.bp==other.bp and self.cp==other.cp) \
			or (self.ap==other.bp and self.bp==other.cp and self.cp==other.ap) \
			or (self.ap==other.cp and self.bp==other.ap and self.cp==other.bp)
	def __add__(self,v):
		return Triangle(self.ap+v,self.bp+v,self.cp+v)
	def __sub__(self,v):
		return Triangle(self.ap-v,self.bp-v,self.cp-v)
	def rotated(self,th):
		return Triangle(self.ap.rotated(th),self.bp.rotated(th),self.cp.rotated(th))
	def rotatedWithCenter(self,th,p):
		return (self-p).rotated(th)+p
	def area(self):
		return abs((self.cp-self.ap).outprod(self.bp-self.cp))/2
	def gravityCenter(self):	#juushin
		return (self.ap+self.bp+self.cp)/3
	def innerCenter(self):		#naishin
		return crossPoints(angleBisector(self.ae,self.be), angleBisector(self.be,self.ce))[0]
	def exterCenter(self):		#gaishin
		return crossPoints(perpendicularBisector(self.ae), perpendicularBisector(self.be))[0]
	def orthoCenter(self):		#suishin
		return crossPoints(perpendicular(self.ap,self.ae), perpendicular(self.bp,self.be))[0]

def crossPoints(m,n):
	if (isinstance(m,DirSegLine) or isinstance(m,SegLine) or isinstance(m,HalfLine) or isinstance(m,Line)) \
			and (isinstance(n,DirSegLine) or isinstance(n,SegLine) or isinstance(n,HalfLine) or isinstance(n,Line)):
		c = m.dv.outprod(n.dv)
		if abs(c)<eps: return []
		s = n.dv.outprod(m.ap-n.ap) / c
		t = m.dv.outprod(n.ap-m.ap) / c
		if (     ((isinstance(m,DirSegLine) or isinstance(m,SegLine)) and 0<=s<=1)	\
			or   (isinstance(m,HalfLine) and 0<=s)									\
			or   (isinstance(m,Line))												\
		   )and( ((isinstance(m,DirSegLine) or isinstance(m,SegLine)) and 0<=t<=1)	\
			or   (isinstance(m,HalfLine) and 0<=t)									\
			or   (isinstance(m,Line))												\
			):
		   return [m.ap+m.dv*s]
	if (isinstance(m,DirSegLine) or isinstance(m,SegLine) or isinstance(m,HalfLine) or isinstance(m,Line)) \
			and isinstance(n,Circle):
		l=perpendicular(n.p, m)
		if l.bp.isOn(n):
			return [l.bp]
		if l.bp.isOut(n):
			return []
		if l.bp.isIn(n):
			if l.dv==Vector(0,0):
				p1 = n.p+m.dv.e()*n.d
				p2 = n.p-m.dv.e()*n.d
			else:
				r=sqrt(n.d**2-l.d**2)
				p1 = l.bp+Vector(d=r,th=l.th+pi/2)
				p2 = l.bp+Vector(d=r,th=l.th-pi/2)
			re=[]
			if p1.isOn(m): re.append(p1)
			if p2.isOn(m): re.append(p2)
			return re
	if isinstance(m,Circle) \
			and (isinstance(n,DirSegLine) or isinstance(n,SegLine) or isinstance(n,HalfLine) or isinstance(n,Line)):
		return crossPoints(n, m)
	if isinstance(m,Circle) and isinstance(n,Circle):
		if m.p==n.p and abs(m.d-n.d)<eps:		#itchi
			return []
		if abs( abs(m.p-n.p)-(m.d-n.d) )<eps:	#naisetsu(n in m)
			return [(n.p*m.d-m.p*n.d)/(m.d-n.d)]
		if abs(m.p-n.p) < (m.d-n.d):			#naihou(n in m)
			return []
		if abs( abs(m.p-n.p)-(n.d-m.d) )<eps:	#naisetsu(m in n)
			return [(m.p*n.d-n.p*m.d)/(n.d-m.d)]
		if abs(m.p-n.p) < (n.d-m.d):			#naihou(n in m)
			return []
		if abs( abs(m.p-n.p)-(m.d+n.d) )<eps:	#gaisetsu
			return [(m.p*n.d+n.p*m.d)/(m.d+n.d)]
		if abs(m.p-n.p) > (m.d+n.d):			#hanareteru
			return []
		if abs(m.p-n.p) < (m.d+n.d):
			d = abs(m.p-n.p)
			x = (d**2+m.d**2-n.d**2)/(2*d)
			y = sqrt(m.d**2-x**2)
			v1 = Vector(x,y)
			v2 = Vector(x,-y)
			th = (n.p-m.p).th
			return [m.p+v1.rotated(th), m.p+v2.rotated(th)]

def perpendicular(p,m):
	m=Line(m.ap,m.bp)
	ap=p
	th=m.th+pi/2
	bp=crossPoints(m, Line(ap=ap,th=th))[0]
	return DirSegLine(ap,bp)

def angleBisector(m,n):
	if m.isParaWith(n):
		return Line(ap=(m.ap+n.ap)/2,th=m.th)
	else:
		return Line(ap=crossPoints(Line(m.ap,m.bp),Line(n.ap,n.bp))[0], th = (m.th+n.th)/2)

def perpendicularBisector(m):
	return Line(ap=(m.ap+m.bp)/2,th=m.th+pi/2)


class Ufo:
	def __init__(self,px,py,d,vd,i):
		p=Vector(px,py)
		self.p=p
		self.d=d
		self.c=Circle(p,d)
		self.v=-p.e()*vd
		self.i=i
	def move(self): #genten toottaka wo kaesu
		if(abs(self.p)<=abs(self.v)): return True
		self.p=self.p+self.v
		self.c=self.c+self.v
		return False

class Laser:
	def __init__(self,u,R):	#yuukou hanni R ijou de u ni mukatte utu
		self.line = HalfLine(ap=neu.p.e()*R, bp=neu.p)

while True:
	R,ul = tuple(map(int,raw_input().split()))
	if(R==0 and ul==0): break
	ignArea = Circle(Vector(0,0),R)
	us=[]
	for ui in xrange(ul):
		px,py,d,vd = tuple(map(int,raw_input().split()))
		u = Ufo(px,py,d,vd,ui)
		us.append(u)
	
	re=0
	while True:
		#print "ufos moved"
		rus=[] #us to be removed
		for u in us:
			passed = u.move()
			if passed or u.p.isIn(ignArea):
				re+=1
				rus.append(u)
		for u in rus:
			#print u.i, "removed due to it invaded inside"
			us.remove(u)

		if len(us)==0:
			break

		neu=Ufo(inf,inf,1,1,1000)
		for u in us:
			if abs(u.p)<abs(neu.p):
				neu=u
		laser = Laser(neu,R)

		rus=[]
		for u in us:
			if len(crossPoints(laser.line, u.c))!=0:
				#print u.i, "removed due to laser hit"
				rus.append(u)
		for u in rus:
			us.remove(u)

		if len(us)==0:
			break

	print re

### FIXED CODE ###

from math import sqrt

class Ufo:
	def __init__(self,px,py,d,vd,ui):
		self.pd=sqrt(px**2+py**2)
		self.px=float(px)
		self.py=float(py)
		self.ex=self.px/self.pd
		self.ey=self.py/self.pd
		self.d=float(d)
		self.vd=float(vd)
		self.vx=-self.vd*self.ex
		self.vy=-self.vd*self.ey
		self.i=ui
	def move(self):
		self.pd -= self.vd
		self.px += self.vx
		self.py += self.vy



while True:
	R,ul=tuple(map(int,raw_input().split()))
	if(R==0 and ul==0): break
	us=[]
	for ui in xrange(ul):
		px,py,d,vd = tuple(map(int,raw_input().split()))
		u = Ufo(px,py,d,vd,ui)
		us.append(u)

	re=0
	while True:
		for u in us: u.move()
		us.sort(key=lambda u: u.pd)

		for u in us[:]:
			if u.pd<=R:
				re+=1
				us.remove(u)
				#print u.i, "due to invade"
				continue
			else:
				break
		if len(us)==0: break

		neu=us.pop(0)
		#print "focus",neu.i
		#print neu.i,"due to hit"

		for u in us[:]:
			d = u.pd*abs(neu.ex*u.ey-neu.ey*u.ex)	#u kara laser ni orosita suisen no nagasa
			if d<u.d:
				if u.pd*(neu.ex*u.ex+neu.ey*u.ey)+sqrt(u.d**2-d**2) > R:
					us.remove(u)
					#print u.i, "due to hit"
		if len(us)==0: break

	print re