#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
#include<stack>

using namespace std;

typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<string> vstring;
typedef vector<pint> vpint;
typedef stringstream SS;

template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }

#define rep(i,n) for(int i=0;i<(n);++i)
#define repn(i,m,n) for(int i=(m);i<(n);++i)
#define repd(i,n) for(int i=(n)-1;i>=0;--i)
#define repnd(i,m,n) for(int i=(n)-1;i>=(m);--i)
#define rep0(i,n) for(i=0;i<(n);++i)
#define repn0(i,m,n) for(i=(m);i<(n);++i)
#define repd0(i,n) for(i=(n)-1;i>=0;--i)
#define repnd0(i,m,n) for(i=(n)-1;i>=(m);--i)
#define repc(i,n) for(int i=0;i<=(n);++i)
#define repcn(i,m,n) for(int i=(m);i<=(n);++i)
#define repcd(i,n) for(int i=(n);i>=0;--i)
#define repcnd(i,m,n) for(int i=(n);i>=(m);--i)
#define repc0(i,n) for(i=0;i<=(n);++i)
#define repcn0(i,m,n) for(i=(m);i<=(n);++i)
#define repcd0(i,n) for(i=(n);i>=0;--i)
#define repcnd0(i,m,n) for(i=(n);i>=(m);--i)
#define all(n) n.begin(),n.end()
#define sz(n) ((int)(n).size())
#define IL for(;;)
#define MP make_pair
#define PB push_back
#define X second
#define Y first
#define p_queue(n) priority_queue<n,vector<n>,greater<n> >
#define PUTLINE cout<<"LINE:"<<__LINE__<<endl;

const int INF = 2147483647/3;
const double EPS = 1e-10;
const double PI = acos(-1.0);

const int dx[]={1,-1,0,0,1,1,-1,-1,0};
const int dy[]={0,0,1,-1,1,-1,1,-1,0};

int sig(double r) { return r < -EPS ? -1 : r > EPS ? 1 : 0; }

struct P {
	double x, y;
	P() {}
	P(double x, double y) : x(x), y(y) {}
	P operator+(const P &a) const { return P(x + a.x, y + a.y); }
	P operator-(const P &a) const { return P(x - a.x, y - a.y); }
	P operator*(const P &a) const { return P(x * a.x - y * a.y, x * a.y + y * a.x); }
	P operator-() const { return P(-x, -y); }
	P operator*(const double &k) const { return P(x * k, y * k); }
	P operator/(const double &k) const { return P(x / k, y / k); }
	double abs2() const { return x * x + y * y; }
	double abs() const { return sqrt(abs2()); }
	double arg() const { return atan2(y, x); }
	double dot(const P &a) const { return x * a.x + y * a.y; }
	double det(const P &a) const { return x * a.y - y * a.x; }
	P proj(const P &a) const { double k = dot(a) / abs2(); return P(x * k, y * k); }
	bool operator<(const P &a) const { return x != a.x ? x < a.x : y < a.y; }
	bool operator==(const P &a) const { return sig(x - a.x) == 0 && sig(y - a.y) == 0; }
};

ostream &operator<<(ostream&os, const P&a) { os << "(" << a.x << ", " << a.y << ")"; return os; }
double tri(P a, P b, P c) { return (b - a).det(c - a); }

struct L {
	P a, b;
	L() {}
	L(P a, P b) : a(a), b(b) {}
	P vec() const { return b - a; }
	P proj(const P &p) const { return a + vec().proj(p - a); }
	P refl(const P &p) const { return proj(p) * 2 - p; }
	int iSP(const P &p) const {
		int s = sig(vec().det(p - a));
		if (s != 0) return s;
		if (sig(vec().dot(p - a)) < 0) return -2;
		if (sig(vec().dot(p - b)) < 0) return 2;
		return 0;
	}
	int iLL(const L &l) const {
		if (sig(vec().det(l.vec()))) return 1;
		if (sig(vec().det(l.a - a))) return 0;
		return -1;
	}
	bool iLS(const L &l) const { return sig(tri(a, b, l.a)) * sig(tri(a, b, l.b)) <= 0; }
	bool iSS(const L &l) const { return iLS(l) && l.iLS(*this); }
	P pLL(const L &l) const { return a + vec() * (l.a - a).det(l.vec()) / b.det(l.vec()); }
	double dLP(const P &p) const { return abs(tri(a, b, p)) / vec().abs(); }
	double dSP(const P &p) const {
		if (sig(vec().dot(p - a)) <= 0) return (p - a).abs();
		if (sig(vec().dot(p - b)) >= 0) return (p - b).abs();
		return dLP(p);
	}
	double dLL(const L &l) const { return iLL(l) ? 0 : dLP(l.a); }
	double dLS(const L &l) const { return iLS(l) ? 0 : min(dLP(l.a), dLP(l.b)); }
	double dSS(const L &l) const { return iSS(l) ? 0 : min(min(dSP(l.a), dSP(l.b)), min(l.dSP(a), l.dSP(b))); }
};

struct C {
	P p;
	double r;
	C() {}
	C(P p, double r) : p(p), r(r) {}
	int iCC(C c) {
		double d = (c.p - p).abs();
		if (sig(d) == 0 && sig(r - c.r) == 0) return -1;
		if (sig(r - c.r - d) > 0) return 2;
		if (sig(c.r - r - d) > 0) return -2;
		return (sig(r + c.r - d) >= 0) ? 1 : 0;
	}
	bool iCS(L l) {
		return (sig(r - l.dSP(p)) >= 0&& sig(r - max((l.a - p).abs(), (l.b - p).abs())) <= 0);
	}
	pair<P,P> pCC(C c) {
		double d = (c.p - p).abs();
		double x = (d * d + r * r - c.r * c.r) / (d * 2);
		P e = (c.p - p) / d, w = e * P(0, 1) * sqrt(max(r * r - x * x, 0.0));
		return make_pair(p + e * x - w, p + e * x + w);
	}
	pair<P,P> pCL(L l) {
		P h = l.proj(p);
		double d = (h - p).abs();
		double y = sqrt(max(r * r - d * d, 0.0));
		P e = (l.b - l.a) / (l.b - l.a).abs();
		return make_pair(h - e * y, h + e * y);
	}
	pair<P,P> tCP(P p) {
		double d2 = (p - this->p).abs2();
		double x = sqrt(max(d2 - r * r, 0.0));
		P h = this->p + (p - this->p) * (r * r / d2);
		P w = (p - this->p) * P(0, 1) * (x * r / d2);
		return make_pair(h - w, h + w);
	}
	double aCC(C c) {
		double d = (p - c.p).abs();
		if (sig(r - c.r - d) >= 0) return c.r * c.r * PI;
		if (sig(c.r - r - d) >= 0) return r * r * PI;
		if (sig(r + c.r - d) <= 0) return 0;
		double x = (d * d + r * r - c.r * c.r) / (d * 2);
		double h = sqrt(r * r - x * x);
		return r * r * atan2(h, x) + c.r * c.r * atan2(h, d - x) - d * h; 
	}
};


int main() {
	int x[3], y[3];
	int xx, yy, r;
	P p[3],g;
	L s[3];
	C c;
	IL {
		cin >> x[0] >> y[0];
		if (x[0] == 0 && y[0] == 0) break;
		cin >> x[1] >> y[1];
		cin >> x[2] >> y[2];
		cin >> xx >> yy;
		cin >> r;
		rep(i, 3) p[i] = P(x[i], y[i]);
		g = (p[0] + p[1] + p[2]) / 3;
		rep(i, 3) s[i] = L(p[i], p[(i+1)%3]);
		c = C(P(xx, yy), r);
		if (!(L(g, c.p)).iSS(s[0]) && !(L(g, c.p)).iSS(s[1]) && !(L(g, c.p)).iSS(s[2]) && sig(s[0].dSP(c.p) - c.r) >= 0 && sig(s[1].dSP(c.p) - c.r) >= 0 && sig(s[2].dSP(c.p) - c.r) >= 0) {
			cout << "a" << endl;
			continue;
		}
		if (sig((c.p - p[0]).abs() - r) <= 0 && sig((c.p - p[1]).abs() - r) <= 0 && sig((c.p - p[2]).abs() - r) <= 0) {
			cout << "b" << endl;
			continue;
		}
		if (sig(s[0].dSP(c.p) - c.r) <= 0 || sig(s[1].dSP(c.p) - c.r) <= 0 || sig(s[2].dSP(c.p) - c.r) <= 0) {
			cout << "c" << endl;
			continue;
		}
		cout << "d" << endl;
	}
	return 0;
}