#include<stdio.h>
#include<algorithm>
#include<math.h>
using namespace std;
const double EPS = 1e-8;
const double INF = 1e+10;
const double PI = acos(-1);
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline double ABS(double a){return max(a,-a);}
struct Pt {
	double x, y;
	Pt() {}
	Pt(double x, double y) : x(x), y(y) {}
	Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
	Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
	Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
	Pt operator-() const { return Pt(-x, -y); }
	Pt operator*(const double &k) const { return Pt(x * k, y * k); }
	Pt operator/(const double &k) const { return Pt(x / k, y / k); }
	double ABS() const { return sqrt(x * x + y * y); }
	double abs2() const { return x * x + y * y; }
	double arg() const { return atan2(y, x); }
	double dot(const Pt &a) const { return x * a.x + y * a.y; }
	double det(const Pt &a) const { return x * a.y - y * a.x; }
};
double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }
int iSP(Pt a, Pt b, Pt c) {
	int s = sig((b - a).det(c - a));
	if (s) return s;
	if (sig((b - a).dot(c - a)) < 0) return -2; // c-a-b
	if (sig((a - b).dot(c - b)) < 0) return +2; // a-b-c
	return 0;
}
bool iSS(Pt a, Pt b, Pt c, Pt d) {
	return (iSP(a, b, c) * iSP(a, b, d) <= 0 && iSP(c, d, a) * iSP(c, d, b) <= 0);
}
int g[110][110];
Pt p[110][3];
int UF[110];
int v[110];
int FIND(int a){
	if(UF[a]<0)return a;
	return UF[a]=FIND(UF[a]);
}
void UNION(int a,int b){
	a=FIND(a);b=FIND(b);if(a==b)return;UF[a]+=UF[b];UF[b]=a;
}
int main(){
	int a,b;
	while(scanf("%d%d",&a,&b),a){
		for(int i=0;i<a;i++)UF[i]=-1;
		for(int i=0;i<a;i++)for(int j=0;j<a;j++)g[i][j]=0;
		for(int i=0;i<a;i++)g[i][i]=1;
		for(int i=0;i<a;i++){
			double ax,bx,cx,ay,by,cy;
			scanf("%lf%lf%lf%lf%lf%lf",&ax,&ay,&bx,&by,&cx,&cy);
			double A=(bx-cx)*(bx-cx)+(by-cy)*(by-cy);
			double B=(ax-cx)*(ax-cx)+(ay-cy)*(ay-cy);
			double C=(ax-bx)*(ax-bx)+(ay-by)*(ay-by);
			if(ABS(A-B)<EPS){
				p[i][0]=Pt(ax,ay);p[i][1]=Pt(bx,by);p[i][2]=Pt(cx,cy);
			}
			if(ABS(B-C)<EPS){
				p[i][2]=Pt(ax,ay);p[i][0]=Pt(bx,by);p[i][1]=Pt(cx,cy);
			}
			if(ABS(C-A)<EPS){
				p[i][1]=Pt(ax,ay);p[i][2]=Pt(bx,by);p[i][0]=Pt(cx,cy);
			}
		}
		for(int i=0;i<a;i++)if(iSP(p[i][0],p[i][2],p[i][1])==-1)swap(p[i][0],p[i][1]);
		for(int i=0;i<a;i++)for(int j=0;j<a;j++){
			if(i==j)continue;
			Pt t[4];
			t[0]=p[i][0];
			t[1]=p[i][1];
			t[3]=(t[1]-t[0])*Pt(0,-1);
			t[3]=t[0]+t[3]/t[3].ABS()*(double)b;
			t[2]=(t[1]-t[0])*Pt(0,-1);
			t[2]=t[1]+t[2]/t[2].ABS()*(double)b;
		
			bool ok=false;
			for(int k=0;k<3;k++){
				bool L=false;
				bool R=false;
				for(int l=0;l<4;l++){
					if(iSS(t[l],t[(l+1)%4],p[j][k],p[j][k]+(p[j][(k+1)%3]-p[j][k])*1000000.0))L=true;
					if(iSS(t[l],t[(l+1)%4],p[j][(k+1)%3],p[j][(k+1)%3]+(p[j][k]-p[j][(k+1)%3])*1000000.0))R=true;
					if(iSS(t[l],t[(l+1)%4],p[j][k],p[j][(k+1)%3]))ok=true;
				}
				if(L&&R)ok=true;
			}
			for(int l=0;l<4;l++){
				bool L=false;
				bool R=false;
				for(int k=0;k<3;k++){
					if(iSS(t[l],t[l]+(t[(l+1)%4]-t[l])*1000000.0,p[j][k],p[j][(k+1)%3]))L=true;
					if(iSS(t[(l+1)%4],t[(l+1)%4]+(t[l]-t[(l+1)%4])*1000000.0,p[j][k],p[j][(k+1)%3]))R=true;
				}
				if(L&&R)ok=true;
			}
			
			if(ok){
				g[i][j]=1;
			}
		}
		for(int k=0;k<a;k++)for(int i=0;i<a;i++)for(int j=0;j<a;j++)
			g[i][j]|=g[i][k]&g[k][j];
		for(int i=0;i<a;i++)for(int j=0;j<a;j++)if(g[i][j]&&g[j][i])UNION(i,j);
		int ret=0;
		for(int i=0;i<a;i++)v[i]=0;
		for(int i=0;i<a;i++){
			bool ok=true;
			for(int j=0;j<a;j++){
				if(FIND(i)!=FIND(j)&&g[j][i])ok=false;
			}
			if(ok&&!v[FIND(i)]){
				ret++;v[FIND(i)]=1;
			}
		}
		printf("%d\n",ret);
	}
}

Measured memory_bytes: 1116