import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

auto readInts() {
	return array(map!(to!int)(readln().strip().split()));
}
auto readInt() {
	return readInts()[0];
}
auto readLongs() {
	return array(map!(to!long)(readln().strip().split()));
}
auto readLong() {
	return readLongs()[0];
}

void readlnTo(T...)(ref T t) {
    auto s = readln().split();
    assert(s.length == t.length);
    foreach(ref ti; t) {
        ti = s[0].to!(typeof(ti));
        s = s[1..$];
    }
}

const real eps = 1e-10;

long r2(long[] p1, long[] p2) {
    long[] d = [p1[0]-p2[0], p1[1]-p2[1]];
    return d[0]*d[0] + d[1]*d[1];
}

long dot(long[] x1, long[] x2) {
    return x1[0] * x2[0] + x1[1] * x2[1];
}

long[] sub(long[] x1, long[] x2) {
    return [x1[0]-x2[0], x1[1]-x2[1]];
}
long[] add(long[] x1, long[] x2) {
    return [x1[0]+x2[0], x1[1]+x2[1]];
}

double d2(long[] p1, long[] p2, long[] x) {
    long[] p21 = sub(p2, p1);
    long[] p1x = sub(p1, x);
    return (dot(p21, p21)*dot(p1x,p1x) - pow(dot(p21, p1x), 2))/to!double(dot(p21,p21));
}

long cross(long[] x, long[] y) {
    return x[0]*y[1] - x[1]*y[0];
}

bool inTriangle(long[] p1, long[] p2, long[] p3, long[] x) {
    auto u = sub(p1, x);
    auto v = sub(p2, x);
    auto w = sub(p3, x);
    
    auto a = cross(u, v);
    auto b = cross(v, w);
    auto c = cross(w, u);

    return a*b > 0 && b*c > 0 && c*a > 0;
}

bool hasIntersection(long[] p1, long[] p2, long[] r0, long r) {
    auto p21 = sub(p2, p1);
    auto p1r = sub(p1, r0);
    auto f0 = dot(p1r, p1r) - r*r;
    auto f1 = dot(add(p21, p1r), add(p21, p1r)) - r*r;
    if(f0 * f1 <= 0) {
        return true;
    }
    if(f0 < 0 && f1 < 0) {
        return false;
    }
    if(dot(p21, p1r) > 0 || abs(dot(p21, p1r)) > dot(p21, p21)) {
        return false;
    }
    return -pow(dot(p21, p1r), 2) + dot(p1r, p1r)*dot(p21, p21) - r*r*dot(p21, p21) <= 0;
}

string test(long[] p1, long[] p2, long[] p3, long[] p4, long r) {
    if(inTriangle(p1, p2, p3, p4) && min(d2(p1, p2, p4), d2(p2, p3, p4), d2(p3, p1, p4)) >= r*r) {
        return "a";
    }
    if(r2(p1, p4) <= r*r && r2(p2,p4) <= r*r && r2(p3,p4) <= r*r) {
        return "b";
    }
    if(hasIntersection(p1, p2, p4, r) || hasIntersection(p2, p3 ,p4, r) || hasIntersection(p3, p1, p4, r)) {
        return "c";
    }
    return "d";
}

void main(){
    while(true) {
        auto xy1 = readLongs();
        if(xy1[0] == 0 && xy1[1] == 0) {
            return;
        }
        auto xy2 = readLongs();
        auto xy3 = readLongs();
        auto xy4 = readLongs();
        auto r = readLong();
        writeln(test(xy1, xy2, xy3, xy4, r));
    }
}