#include <cstdio>
#include <cstring>
#include <set>
#include <complex>
#include <cmath>
#include <algorithm>
using namespace std;

typedef double T;
const T EPS = 1e-9;

typedef complex<T> P;


int round1(double x) {
	double ax = fabs(x);
	int res = ax + double(0.5 + EPS);
	if(x > 0) {
		return res;
	}
	else {
		return -res;
	}
}

P rot[400];
int rt;

typedef pair<int,int> pii;
set<pair<int, pair<pii, pii> > > sol;

void addRot(int x, int y) {
	P p = P(x, y);
	rot[rt++] = p / abs(p);
}

pii applyRot(pii p, int id) {
	P p1 = P(p.first, p.second);
	p1 *= rot[id];
	return make_pair(round1(p1.real()), round1(p1.imag()));
}

pii a[3];
int rot_rec;
pii arot[3];
pii scale_rec;
pii ascale[3];
pii trans_rec;
pii atrans[3];
pii b[3];

int read32(pii a[3]) {
	int f = 0;
	for(int i = 0; i < 3; ++i) {
		scanf("%d%d", &a[i].first, &a[i].second);
//printf("%d %d\n", a[i].first, a[i].second);
		if(a[i].first != 0 || a[i].second != 0) {
			f = 1;
		}
	}
	return f;
}

typedef set<int>::iterator si;

set<int> fix(set<int> s) {
	set<int> res = s;
	int ma = 0;
	for(si i = s.begin(); i != s.end(); ++i) {
		ma = max(ma, abs(*i));
	}
	res.insert(ma + 1);
	res.insert(ma + 2);
	return res;
}

void check(int dx, int dy) {
	if(sol.size() > 1) return;
	trans_rec = make_pair(dx, dy);
	for(int i = 0; i < 3; ++i) {
		atrans[i] = make_pair(ascale[i].first + dx, ascale[i].second + dy);
	}
	sort(atrans, atrans + 3);
	for(int i = 0; i < 3; ++i) {
		if(atrans[i] != b[i]) {
			return;
		}
	}
//printf("%d    %d %d\n", rot_rec, scale_rec.first, scale_rec.second);
	sol.insert(make_pair(rot_rec,make_pair(scale_rec, trans_rec)));
}

void checkTranslate(int sx, int sy) {
	if(sol.size() > 1) return;
	scale_rec = make_pair(sx, sy);
	for(int i = 0; i < 3; ++i) {
		ascale[i] = make_pair(arot[i].first * sx, arot[i].second * sy);
	}
	for(int i = 0; i < 3; ++i) {
		for(int j = 0; j < 3; ++j) {
			check(b[j].first - ascale[i].first, b[j].second - ascale[i].second);
		}
	}	
}

void checkScale(int r) {
	if(sol.size() > 1) return;
	rot_rec = r;
	for(int i = 0; i < 3; ++i) {
		arot[i] = applyRot(a[i], r);
	}
	set<int> sx, sy;
	for(int i = 0; i < 3; ++i) {
		for(int j = 0; j < 3; ++j) if(i != j) {
			int dxPre = arot[i].first - arot[j].first;
			int dyPre = arot[i].second - arot[j].second;
			for(int i1 = 0; i1 < 3; ++i1) {
				for(int j1 = 0; j1 < 3; ++j1) if(i1 != j1) {
					int dxAft = b[i1].first - b[j1].first;
					int dyAft = b[i1].second - b[j1].second;
					if(dxPre != 0 && dxAft != 0 && dxAft % dxPre == 0) {
						sx.insert(dxAft / dxPre);
					}
					if(dyPre != 0 && dyAft != 0 && dyAft % dyPre == 0) {
						sy.insert(dyAft / dyPre);
					}
				}
			}	
		}
	}
	sx = fix(sx);
	sy = fix(sy);
	for(si i = sx.begin(); i != sx.end(); ++i) {
		for(si j = sy.begin(); j != sy.end(); ++j) {
			if(*i > 0 && *j != 0) {
				checkTranslate(*i, *j);
			}
		}
	}
}

int main() {
//printf("%d\n", round1(0.5));
//printf("%d\n", round1(-0.5));
//printf("%d\n", round1(1.5));
//printf("%d\n", round1(-1.5));
	rt = 0;
	for(int i = -10; i <= 10; ++i) {
		addRot(i, -10);
		addRot(i, 10);
		if(i > -10 && i < 10) {
			addRot(-10, i);
			addRot(10, i);
		}
	}
//printf("%d\n", rt); for(int i = 0; i < rt; ++i) printf("%lf %lf\n", rot[i].real(), rot[i].imag());
	int ct = 0;
	while(read32(a)) {
		read32(b);
		sort(b, b + 3);
		++ct;
		sol.clear();
		for(int i = 0; i < rt; ++i) {
			checkScale(i);
		}
		printf("Case %d: ", ct);
		if(sol.size() == 0) {
			puts("no solution");
		}
		else if(sol.size() == 1) {
			puts("equivalent solutions");
		}
		else {
			puts("inconsistent solutions");
		}
	}
	return 0;
}