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;

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

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

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

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

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

bool inTriangle(int[] p1, int[] p2, int[] p3, int[] 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(int[] p1, int[] p2, int[] r0, int 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 -dot(p21, p1r) + 2*(dot(p1r, p1r) - r*r) < 0;
}

string test(int[] p1, int[] p2, int[] p3, int[] p4, int 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 = readInts();
        if(xy1[0] == 0 && xy1[1] == 0) {
            return;
        }
        auto xy2 = readInts();
        auto xy3 = readInts();
        auto xy4 = readInts();
        auto r = readInt();
        writeln(test(xy1, xy2, xy3, xy4, r));
    }
}