#include <cstdio>
#include <cmath>
#include <cfloat>
#include <cstring>
#include <cassert>
#include <vector>
#include <algorithm>
using namespace std;

#define EPS (1e-8)

class Point{
public:
	double x, y;
	Point ( double x = 0, double y = 0): 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 * ( double a ){ return Point(x*a, y*a); }
	double abs() { return sqrt(norm());}
	double norm() { return x*x + y*y; }
	bool operator < ( const Point &p ) const {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator == ( const Point &p ) const {
		return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS;
	}
};

typedef Point Vector;
typedef vector<Point> Polygon;

double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs(Vector a) {return (sqrt(norm(a)));}
double abs(Vector a, Vector b) {return (sqrt(norm(a - b)));}
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }

double eq(double a, double b)
{
	return (fabs(a - b) <= EPS);
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

//3点の位置関係を求める
int ccw( Point p0, Point p1, Point p2 ){
	Vector a = p1 - p0;
	Vector 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;
}

//A = p2 - p1, B = p4 - p3が交差するか
bool isIntersect(Point p1, Point p2, Point p3, Point p4){
	return ( ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
				ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0 );
}



//多角形の中に点があるか
bool isInside(Polygon gon, Point p ){
	for ( int i = 0; i < gon.size(); i++ ){
		if ( ccw(gon[i], gon[(i+1)%gon.size()], p) == CLOCKWISE ) return (false);
	}
	return (true);
}

//単位ベクトルを求める
Point unitVector(Point t){
	double u=abs(t);
	return Point(t.x/u , t.y/u);
}
//cosθを求める
double getcos(Point a , Point b){
	return (dot(a,b) / (abs(a)*abs(b)));
}

//sinθを求める
double getsin(Point a , Point b){
	double t=getcos(a,b);
	return sqrt(1.0-t*t);
}

//点pと直線abとの距離を求める
double pld(Point p , Point a , Point b){
	return fabs(cross(b - a,p - a))/abs(b-a);
}

//点pと線分abとの距離を求める
double psd(Point p , Point a , Point b){
	if( dot( b-a , p-a ) < EPS) return abs(p-a);
	if( dot( a-b , p-b ) < EPS) return abs(p-b);
	return fabs(cross( b-a , p-a )) / abs(b-a);
}

//線分交点計算
Point interpointS(Point a1 , Point a2 , Point b1 , Point b2){
	Point b=b2-b1;
	double d1=fabs(cross(b , a1-b1));
	double d2=fabs(cross(b , a2-b1));
	double t=d1 / (d1 + d2);
	Point a=a2-a1;
	Point v=a*t;
	return a1+v;
}

//直線交点計算
Point interpointL(Point a1 , Point a2 , Point b1 , Point b2){
	Point a=a2-a1;
	Point b=b2-b1;
	double t=cross(b , b1-a1) / cross(b , a);
	Point v=a*t;
	return a1+v;
}

//直線abと円及び球 |x-c|=rの交点を求める 　球の場合は型Point→Sに変更するだけ
void interpointLC(Point a , Point b , Point c , double r , Point ans[]){
	if(pld(c , a , b) > r + EPS) return;
	Point v=unitVector(b-a);
	double delta=dot(v,a-c)*dot(v,a-c)-abs(a-c)*abs(a-c)+r*r;
	double t=-dot(v,a-c);
	double s=sqrt(delta);
	ans[0]=a+v*(t+s);
	ans[1]=a+v*(t-s);
}

//１次変換集

//ｘ（y=k）に関する対象変換 　k=0でｘ軸による変換
Point xTranslate(Point t,double k){
	return Point(t.x , 2*k-t.y);
}

//ｙ(x=k)に関する対象変換	k=0でｙ軸による変換
Point yTranslate(Point t,double k){
	return Point(2*k-t.x , t.y);
}

//点Point kに関する対象変換		Point(0,0)で原点による変換
Point oTranslate(Point t,Point k){
	return k+(k-t);
}





//点pを中心としてr(radian)回転		p(0,0)で原点を中心として回転
Point rotate(Point t , Point p , double r){
	//double r=radians(angle);
	double ta=cos(r)*(t.x-p.x)-sin(r)*(t.y-p.y)+p.x;
	double tb=sin(r)*(t.x-p.x)+cos(r)*(t.y-p.y)+p.y;
	return Point(ta , tb);
}

//応用
//２円 |x-a|=raと|x-b|=rbの交点計算
void interpointCC(Point a , double ra , Point b , double rb , Point ans[]){
	double di=fabs(abs(a-b));
	if(di > ra+rb || di < fabs(ra-rb)) return;
	double t=(ra*ra-rb*rb+di*di)/(di+di);
	double rd=acos(t/ra);

	Point dv=unitVector(b-a);
	Point g1=rotate(dv , Point(0,0) , rd);
	Point g2=rotate(dv , Point(0,0) , -rd);
	ans[0]=a+g1*ra;
	ans[1]=a+g2*ra;
}

//法線ベクトルを求める
Point normalVector(Point p,Point a,Point b){
	Point v=unitVector(b-a);
	v = cross(v , p-a) > 0 ?  Point(v.y,(-1)*v.x) : Point((-1)*v.y , v.x);
	return v*pld(p,a,b);
}

//直線abに関する対象変換
Point fTranslate(Point t , Point a , Point b){
	return t+normalVector(t,a,b)*2;
}

//３角形の面積を求める
double area(Point a, Point b, Point c){
	return fabs(cross(c-a , b-a)*0.5);
}

//多角形の面積を求める //凸包のソート済みが前提
double polygonArea(Polygon t){
	double ans=0.0;
	for(unsigned int i=0;i<t.size();i++)
		ans+=cross(t[i] , t[(i+1)%t.size()]);
	return ans/2;
}

Polygon conhel(Polygon& ps)
{
    sort(ps.begin(), ps.end());
    int k = 0, n = static_cast<int>(ps.size());
    Polygon qs(n * 2);
    for (int i = 0; i < n; ++i) {
      while (k > 1 && cross(qs[k-1] - qs[k-2], ps[i] - qs[k-1]) < EPS)
	--k;
      qs[k++] = ps[i];
    }

    for (int i = n-2, t = k; i >= 0; --i) {
      while (k > t && cross(qs[k-1] - qs[k-2], ps[i] - qs[k-1]) < EPS)
	--k;
      qs[k++] = ps[i];
    }

    qs.resize(k-1);
    return qs;
}

Polygon tri[100];
int n, d;

bool isIn(Polygon a, Polygon b)
{
	for (int i = 0; i < a.size(); i++) if (isInside(b, a[i])) return (true);
	for (int i = 0; i < b.size(); i++) if (isInside(a, b[i])) return (true);
	for (int i = 0; i < a.size(); i++){
		for (int j = 0; j < b.size(); j++){
			if (isIntersect(a[i], a[(i + 1) % a.size()], b[j], b[(j + 1) % b.size()])) return (true);
		}
	}
	return (false);
}

Polygon normalize(Polygon a)
{
	if (eq(abs(a[0] - a[1]), abs(a[1] - a[2])))
		swap(a[1], a[2]);
	else if (eq(abs(a[0] - a[2]), abs(a[0] - a[1])))
		swap(a[0], a[2]);
	
	if (ccw(a[0], a[1], a[2]) != COUNTER_CLOCKWISE) swap(a[0], a[1]);
	
	return (a);
}

bool check(Polygon a, Polygon b)
{
	Polygon c;
	c.push_back(a[0]); c.push_back(a[1]);
	
	Point t = Point((a[0].x + a[1].x) / 2, (a[0].y + a[1].y) / 2);
	Point k = a[2] - t;
	c.push_back(a[1] + unitVector(k) * d); c.push_back(a[0] + unitVector(k) * d);
	
	return (isIn(c, b));
}

vector<int> G[128], rG[128];
int ord[128], gr[128];
bool vis[128];
int ctr;

void addEdge(int src, int dst)
{
	G[src].push_back(dst);
	rG[dst].push_back(src);
}

void dfs1(int v)
{
	vis[v] = true;
	for (int i = 0; i < G[v].size(); i++){
		if (!vis[G[v][i]]) dfs1(G[v][i]);
	}
	ord[ctr++] = v;
}

void dfs2(int v, int k)
{
	vis[v] = true;
	gr[v] = k;
	for (int i = 0; i < rG[v].size(); i++){
		if (!vis[rG[v][i]]) dfs2(rG[v][i], k);
	}
	
}

int scc()
{
	
	memset(vis, 0, sizeof(vis));
	ctr = 0;
	
	for (int i = 0; i < n; i++){
		if (!vis[i]){
			dfs1(i);
		}
	}
	
	int k = 0;
	memset(vis, 0, sizeof(vis));
	for (int i = n - 1; i >= 0; i--){
		if (!vis[ord[i]]){
			dfs2(ord[i], k++);
		}
	}
	
	int ret = k;
	memset(vis, 0, sizeof(vis));
	for (int i = 0; i < n; i++){
		for (int j = 0; j < G[i].size(); j++){
			if (gr[i] != gr[G[i][j]]){
				ret -= (1 ^ vis[gr[G[i][j]]]);
				vis[gr[G[i][j]]] = true;
			}
		}
	}
	
	return (ret);
}

int main()
{
	Point t;
	while (scanf("%d %d", &n, &d) && n + d){
		for (int i = 0; i < n; i++){
			tri[i].clear();
			for (int j = 0; j < 3; j++){
				scanf("%lf %lf", &t.x, &t.y);
				tri[i].push_back(Point(t.x, t.y));
			}
			tri[i] = normalize(tri[i]);
			G[i].clear(); rG[i].clear();
		}
		
		for (int i = 0; i < n; i++){
			for (int j = 0; j < n; j++){
				if (i != j && check(tri[i], tri[j])){
					addEdge(i, j);
				}	
			}
		}	
		
		printf("%d\n", scc());
	}
	
	return (0);
}

Measured memory_bytes: 1124