Problem:
最後の扉

秘境の地"ナラマンダ地方"

この奥深い洞窟に眠る黄金の伝説を求め、探検家ボブとマイクは様々な困難に立ち向かいました。ようやくたどり着いた最後の扉。この先には夢に見た黄金が待っています。

その扉には多数の三角形が描かれていました。試しにマイクがその 1 つに触れてみると、その三角形は光を放ちました。光は三角形の底辺から垂直に頂点方向へ長方形を描きながら伸びていき、その先にある別の三角形に触れました。すると、光に触れた三角形も同じように光を放ち、それを繰り返していきました。

扉の三角形は全て二等辺三角形(正三角形は含まない)で、どれも同じ大きさで、どれも重ならず（かつ触れることなく）、またどれも光は一定の距離だけ伸びていました。最後の三角形が光り終えると、そこには何事もなかったかのような静けさが戻ってきました。

ボブは自分の足下に奇妙なメッセージを見つけました。

「むやみに触れるべからず。汝正しくこの扉に触れたとき、この扉は放たれん。 」

ボブとマイクはこのメッセージの意味を考えながら、 何度も三角形に触れてみましたがなかなか扉は開きません。 しかし、それを繰り返していくうちに、二人はメッセージの意味がだんだん分かってきました。

「"むやみに触れるべからず"とは、扉に触れる回数は最小ということ。

できるだけ少ない回数で触れて、全ての三角形を光らせれば、きっと扉は開くはずだ!」

例えば、扉には図 1 のように複数の二等辺三角形が描かれています。

図 1

最初に左下の三角形に触れると、図 2 に示すように、その三角形の底辺から垂直に頂点方向へ光が放たれ、その光が触れる三角形が次々に光ります。

図 2

次に左端の三角形に触れると、図 3 に示すように、全ての三角形が光ります。この手順が全ての三角形を光らせるための最少の手数(2 手)となります。

図 3

さあ、ボブとマイクが最後の扉を開ける手助けをしよう。

扉に描かれている三角形の個数、光の伸びる長さ、それぞれの三角形の頂点の座標を入力とし、全ての三角形を光らせるために扉に触れる最少の回数を出力するプログラムを作成して下さい。光の伸びる長さは、底辺からの長さであるものとします。また、光はそれを放つ三角形の頂点を含むような十分な長さを持ちます。

なお、この問題を解くにあたっては、2 点の距離が 0.01 以下の場合には、同一の点と処理します。また、1 点とひとつの直線の距離が 0.01 以下の場合には、この点はこの直線上にあるとして処理します。

Input

複数のデータセットの並びが入力として与えらる。入力の終わりはゼロふたつの行で示される。各データセットは以下の形式で与えらる。

n d
T1
T2
:
Tn

１行目に扉に描かれている三角形の個数 n (1 ≤ n ≤ 100) と光の伸びる長さを表す整数 d (1 ≤ d ≤ 1000) が与えられる。

続く n 行に各三角形の情報 Ti が以下の形式で与えられる。

x1 y1 x2 y2 x3 y3

三角形の３つの頂点の座標が整数で与えられる(-1000 ≤ x1, y1, x2, y2, x3, y3 ≤ 1000)。

データセットの数は 20 を超えない。

Output

データセットごとに、扉に触れる最少の回数を1行に出力する。

Sample Input

3 4
1 0 3 0 2 1
2 3 2 5 3 4
5 3 5 5 6 4
3 2
1 0 3 0 2 1
2 3 2 5 3 4
5 3 5 5 6 4
0 0

Output for the Sample Input

1
3

Solution in C++11 (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;

#define x() real()
#define y() imag()
#define EPS (1e-6)
#define INF (1e12)
#define SQ(a) ((a) * (a))
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).x(), (b).x()) && EQ((a).y(), (b).y()))

enum {
	COUNTER_CLOCKWISE = 1,
	CLOCKWISE = -1,
	ONLINE_BACK = 2,
	ONLINE_FRONT = -2,
	ON_SEGMENT = 0
};
enum {OUT, ON, IN};

typedef double D;
typedef complex<D> P;
typedef P V;
namespace std {
	bool operator < (const P &a, const P &b){
		if (a.x() != b.x()) return a.x() < b.x();
		return a.y() < b.y();
	}
}
struct S{
	P p1, p2;
	S(){}
	S(P p1, P p2): p1(p1), p2(p2){}
};
typedef S L;
typedef S PP;
struct C{
	P p;
	D r;
	C(){}
	C(P p, D r): p(p), r(r){}
};
typedef vector<P> G;
struct Edge {
	int to;
	D cost;
	Edge(){}
	Edge(int to, D cost = 0.0): to(to), cost(cost){}
	bool operator < (const Edge &t) const {
		return cost > t.cost;
	}
};
typedef vector<vector<Edge> > Graph;

inline D inD(){
	D d;
	scanf("%lf", &d);
	return d;
}
inline P inP(){
	D x = inD(), y = inD();
	return P(x, y);
}
inline S inS(){
	P p1(inP());
	P p2(inP());
	return S(p1, p2);
}
inline C inC(){
	P p(inP());
	D r(inD());
	return C(p, r);
}

D norm(P a){
	return SQ(a.x()) * SQ(a.y());
}
D dot(P a, P b){
	return (conj(a) * b).x();
}
D cross(P a, P b){
	return (conj(a) * b).y();
}
bool orthogonal(L a, L b){
	return EQ( dot(a.p1 - a.p2, b.p1 - b.p2), 0.0 );
}
bool parallel(L a, L b){
	return EQ( cross(a.p1 - a.p2, b.p1 - b.p2), 0.0 );
}
bool PonL(L l, P p){
	return EQ( cross(l.p1 - l.p2, p - l.p2), 0.0 );
}
bool PonS(S s, P p){
	return EQ( cross(s.p1 - s.p2, p - s.p2), 0.0 ) &&
		(dot(s.p1 - s.p2, p - s.p2) > -EPS) &&
		(dot(s.p2 - s.p1, p - s.p1) > -EPS);
}
P project(S s, P p){
	V base = s.p2 - s.p1;
	D r = dot(p - s.p1, base) / norm(base);
	return s.p1 + base * r;
}
P reflect(S s, P p){
	return p + (project(s, p) - p) * 2.0;
}
int ccw(P p0, P p1, P p2){
	P a = p1 - p0;
	P 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;
}
bool intersectLL(L l1, L l2){
	return !parallel(l1, l2) ||
		abs( cross(l1.p1 - l1.p2, l2.p1 - l2.p2) ) < EPS;
}
bool intersectLS(L l, S s){
	return cross(l.p2 - l.p1, s.p1) * cross(l.p2 - l.p1, s.p2) < EPS;
}
bool intersectSS(S s1, S s2){
	return ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0 &&
		ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0;
}
bool intersectCC(C c1, C c2){
	return abs(c1.p - c1.p) - (c1.r + c2.r) < EPS;
}
D distanceLP(L l, P p){
	return abs( cross(l.p2 - l.p1, p - l.p1) ) / abs(l.p2 - l.p1);
}
D distanceLL(L l1, L l2){
	return intersectLL(l1, l2) ? 0 : distanceLP(l1, l2.p1);
}
D distanceLS(L l, S s){
	return intersectLS(l, s) ? 
		0 :
		min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
D distanceSP(S s, P p){
	P pr = project(s, p);
	if (PonS(s, pr)) return abs(pr - p);
	return min( abs(s.p1 - p), abs(s.p2 - p) );
}
D distanceSS(S s1, S s2){
	if (intersectSS(s1, s2)) return 0;
	return min(
		min(distanceSP(s1, s2.p1), distanceSP(s1, s2.p2)),
		min(distanceSP(s2, s1.p1), distanceSP(s2, s1.p2))
	);
}

/*
bool intersect(G g1, G g2){
	for (int i = 0; i < g1.size(); i++){
		for (int j = 0; j < g2.size(); j++){
			S s1(g1[i], g1[(i + 1) % g1.size()]);
			S s2(g2[j], g2[(j + 1) % g2.size()]);
			if (intersect(s1, s2)) return true;
		}
	}
	return false;
}
bool intersect(G g, S s){
	for (int i = 0; i < g.size(); i++){
		S s0(g[i], g[(i + 1) % g.size()]);
		if (intersect(s, s0)) return true;
	}
	return false;
}
*/

P crossP(S s1, S s2){
	assert(intersectSS(s1, s2));
	P base = s2.p2 - s2.p1;
	D d1 = abs(cross(base, s1.p1 - s2.p1));
	D d2 = abs(cross(base, s1.p2 - s2.p1));
	D t = d1 / (d1 + d2);
	
	/*if (isnan(t)){
		//printf("%f %f %f %f %f %f %f %f\n", s1.p1.x(), s1.p1.y(), s1.p2.x(), s1.p2.y(), s2.p1.x(), s2.p1.y(), s2.p2.x(), s2.p2.y());
		if (EQV(s1.p1, s2.p1)) return s1.p1;
		if (EQV(s1.p1, s2.p2)) return s1.p1;
		if (EQV(s1.p2, s2.p1)) return s1.p2;
		if (EQV(s1.p2, s2.p2)) return s1.p2;
	}*/
	
	P p = s1.p1 + (s1.p2 - s1.p1) * t;
	//assert(!isnan(p.x()));
	return s1.p1 + (s1.p2 - s1.p1) * t;
}
PP crossPP(C c, L l){
	P pr = project(l, c.p);
	P e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
	D base = sqrt( SQ(c.r) - norm(pr - c.p) );
	return PP(pr + e * base, pr - e * base);
}
PP crossPP(C c1, C c2){
	D d = abs(c1.p - c2.p);
	D a = acos( SQ(c1.r) + SQ(d) - SQ(c2.r) ) / (2 * c2.r * d);
	D t = arg(c2.p - c1.p);
	return PP( c1.p + polar(c1.r, t + a), c1.p + polar(c1.r, t - a) );
}

int contains(G &g, P p){
	int n = g.size();
	bool x = false;
	for (int i = 0; i < n; i++){
		P a = g[i] - p, b = g[(i + 1) % n] - p;
		if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return ON;
		if (a.y() > b.y()) swap(a, b);
		if (a.y() < EPS && EPS < b.y() && cross(a, b) > EPS) x != x;
	}
	return x ? IN : OUT;
}


int n, d;
G tri[100];
G rect[100];
vector<int> graph[100];
vector<int> rgraph[100];


vector<int> vs;
bool used[100];
int cmp[100];
void dfs(int v)
{
	used[v] = true;
	for (int to : graph[v]){
		if (!used[to]) dfs(to);
	}
	vs.push_back(v);
}
void rdfs(int v, int k)
{
	used[v] = true;
	cmp[v] = k;
	for (int to : rgraph[v]){
		if (!used[to]) rdfs(to, k);
	}
}
int scc()
{
	vs.clear();
	fill_n(used, 100, false);
	for (int v = 0; v < n; v++){
		if (!used[v]) dfs(v);
	}
	fill_n(used, 100, false);
	int k = 0;
	for (int i = vs.size() - 1; i >= 0; i--){
		if (!used[vs[i]]) rdfs(vs[i], k++);
	}
	return k;
}
void topoSort(vector<vector<int>>& graph, int v, vector<int> &tps)
{
	used[v] = true;
	for (auto to : graph[v]){
		if (!used[to]) topoSort(graph, to, tps);
	}
	tps.push_back(v);
}

bool intersects(G &a, G &b)
{
	for (int i = 0; i < a.size(); i++){
		for (int j = 0; j < b.size(); j++){
			S sa = S(a[i], a[(i + 1) % a.size()]);
			S sb = S(b[j], b[(j + 1) % b.size()]);
			if (intersectSS(sa, sb)) return true;
		}
	}
	for (int i = 0; i < a.size(); i++){
		if (contains(b, a[i])) return true;
	}
	for (int i = 0; i < b.size(); i++){
		if (contains(a, b[i])) return true;
	}
	
	return false;
}

int solve()
{
	for (int i = 0; i < n; i++){
		G &t = tri[i];
		for (int j = 0; j < 3; j++){
			P &a = t[j];
			P &b = t[(j + 1) % 3];
			P &c = t[(j + 2) % 3];
			
			// ?????? = t[0] -> t[1]
			// ?????? = t[2]
			if (EQ(abs(b - a), abs(c - a))){
				swap(t[2], a);
				break;
			}
		}
	}
	
	// ????????¢?????????
	for (int i = 0; i < n; i++){
		G &t = tri[i];
		G &r = rect[i];
		
		P v = t[1] - t[0];
		P v1 = v * P(0, 1) / abs(v) * (D)d;
		P v2 = v * P(0, -1) / abs(v) * (D)d;
		if (dot(t[2] - t[0], v2) > 0) v1 = v2;
		r.resize(4);
		r[0] = t[0];
		r[1] = t[1];
		r[2] = t[1] + v1;
		r[3] = t[0] + v1;
	}
	
	for (int i = 0; i < n; i++){
		for (int j = 0; j < n; j++){
			if (i == j) continue;
			if (intersects(rect[i], tri[j])){
				graph[i].push_back(j);
				rgraph[j].push_back(i);
			}
		}
	}
	
	int V = scc();
	vector<vector<int>> sccgraph(V);
	vector<vector<int>> rsccgraph(V);
	for (int i = 0; i < n; i++){
		for (int to : graph[i]){
			sccgraph[cmp[i]].push_back(cmp[to]);
			rsccgraph[cmp[to]].push_back(cmp[i]);
		}
	}
	
	vector<int> tps;
	fill_n(used, 100, false);
	for (int i = 0; i < V; i++){
		if (!used[i]) topoSort(rsccgraph, i, tps);
	}
	
	int res = 0;
	fill_n(used, 100, false);
	for (int i = 0; i < V; i++){
		if (!used[i]) res++;
		for (int to : sccgraph[i]){
			used[to] = true;
		}
	}
	
	return res;
}

int main()
{
	while (scanf("%d %d", &n, &d), n){
		for (int i = 0; i < 100; i++){
			tri[i].clear();
			rect[i].clear();
			graph[i].clear();
			rgraph[i].clear();
		}
		
		for (int i = 0; i < n; i++){
			for (int j = 0; j < 3; j++){
				tri[i].push_back(inP());
			}
		}
		
		cout << solve() << endl;
	}
}