Go: package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

var scanner = bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		buf0 := strings.Split(scanner.Text(), " ")
		input0 := make([]int, 2)
		for i := range input0 {
			input0[i], _ = strconv.Atoi(buf0[i])
		}
		if input0[0] == 0 && input0[1] == 0 {
			break
		}
		a, b := input0[0], input0[1]
		scanner.Scan()
		buf1 := strings.Split(scanner.Text(), " ")
		input1 := make([]int, 2)
		for i := range input1 {
			input1[i], _ = strconv.Atoi(buf1[i])
		}
		c, d := input1[0], input1[1]
		scanner.Scan()
		buf2 := strings.Split(scanner.Text(), " ")
		input2 := make([]int, 2)
		for i := range input2 {
			input2[i], _ = strconv.Atoi(buf2[i])
		}
		e, f := input2[0], input2[1]
		scanner.Scan()
		buf3 := strings.Split(scanner.Text(), " ")
		input3 := make([]int, 2)
		for i := range input3 {
			input3[i], _ = strconv.Atoi(buf3[i])
		}
		g, h := input3[0], input3[1]
		scanner.Scan()
		r, _ := strconv.Atoi(scanner.Text())
		if (a-g)*(a-g)+(b-h)*(b-h) <= r*r && (c-g)*(c-g)+(d-h)*(d-h) <= r*r && (e-g)*(e-g)+(f-h)*(f-h) <= r*r {
			fmt.Println("b")
		} else if dist(a, b, c, d, g, h) > float64(r)-0.000001 && dist(a, b, e, f, g, h) > float64(r)-0.000001 && dist(e, f, c, d, g, h) > float64(r)-0.000001 && inclusive(a, b, c, d, e, f, g, h) {
			fmt.Println("a")
		} else if CL_intersect(a, b, c, d, g, h, r) || CL_intersect(a, b, e, f, g, h, r) || CL_intersect(e, f, c, d, g, h, r) {
			fmt.Println("c")
		} else {
			fmt.Println("d")
		}
	}
}

func CL_intersect(ax, ay, bx, by, cx, cy, r int) bool {
	acx := cx - ax
	acy := cy - ay
	bcx := cx - bx
	bcy := cy - by
	abx := bx - ax
	aby := by - ay
	if acx*acx+acy*acy >= r*r || bcx*bcx+bcy*bcy >= r*r {
		if abx*acx+aby*acy < 0 {
			if acx*acx+acy*acy <= r*r {
				return true
			}
		} else {
			if abx*acx+aby*acy > abx*abx+aby*aby {
				if bcx*bcx+bcy*bcy <= r*r {
					return true
				}
			} else if acx*acx+acy*acy-(abx*acx+aby*acy)*(abx*acx+aby*acy)/(abx*abx+aby*aby) <= r*r {
				return true
			}
		}
	}
	return false
}

func inclusive(ax, ay, bx, by, cx, cy, px, py int) bool {
	ok1 := true
	ok2 := true
	if (bx-ax)*(py-ay)-(px-ax)*(by-ay) < 0 {
		ok1 = false
	}
	if (bx-ax)*(py-ay)-(px-ax)*(by-ay) > 0 {
		ok2 = false
	}
	if (cx-bx)*(py-by)-(px-bx)*(cy-by) < 0 {
		ok1 = false
	}
	if (cx-bx)*(py-by)-(px-bx)*(cy-by) > 0 {
		ok2 = false
	}
	if (ax-cx)*(py-cy)-(px-cx)*(ay-cy) < 0 {
		ok1 = false
	}
	if (ax-cx)*(py-cy)-(px-cx)*(ay-cy) > 0 {
		ok2 = false
	}
	return ok1 || ok2
}

func dist(ax, ay, bx, by, px, py int) float64 {
	dx := float64(bx - ax)
	dy := float64(by - ay)
	A := float64(dx*dx + dy*dy)
	B := dx*float64(ax-px) + dy*float64(ay-py)
	t := -B / A
	if t < 0 {
		t = 0
	}
	if t > 1 {
		t = 1
	}
	tx := float64(ax) + dx*t
	ty := float64(ay) + dy*t
	return math.Sqrt((float64(px)-tx)*(float64(px)-tx) + (float64(py)-ty)*(float64(py)-ty))
}

C++: #include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
static const double eps = 1e-10;
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

bool equals(double a, double b)
{
	return(fabs(a - b) < eps);
}

class Point
{
public:
	double x, y;
	Point(double x = 0, double y = 0) : x(x), y(y){}

	Point operator + (Point p){ return(Point(x + p.x, y + p.y)); }
	Point operator - (Point p){ return(Point(x - p.x, y - p.y)); }
	Point operator * (double a){ return(Point(a * x, a * y)); }
	Point operator / (double a){ return(Point(x / a, y / a)); }

	double abs(){ return(sqrt(norm())); }
	double norm(){ return(x * x + y * y); }

	bool operator < (const Point& p) const
	{
		return(x != p.x ? x < p.x : y < p.y);
	}

	bool operator == (const Point& p) const
	{
		return(fabs(x - p.x) < eps && fabs(y - p.y) < eps);
	}
};
typedef Point Vector;


struct Segment
{
	Point p1, p2;
	Segment(Point p1, Point p2) : p1(p1), p2(p2){};
};
typedef Segment Line;

class Circle
{
public:
	Point c;
	double r;
	Circle(Point c = Point(), double r = 0.0) : c(c), r(r){}
};

double dot(Vector a, Vector b)
{
	return(a.x * b.x + a.y * b.y);
}

double cross(Vector a, Vector b)
{
	return(a.x * b.y - a.y * b.x);
}

Point project(Segment s, Point p)
{
	Vector base = s.p2 - s.p1;
	double r = dot(p - s.p1, base) / base.norm();
	return(s.p1 + base * r);
}

Point reflect(Segment s, Point p)
{
	return(p + (project(s, p) - p) * 2.0);
}

bool isOrthogonal(Vector a, Vector b)
{
	return(equals(dot(a, b), 0.0));
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2)
{
	return(isOrthogonal(a1 - a2, b1 - b2));
}

bool isOrthogonal(Segment s1, Segment s2)
{
	return(equals(dot(s1.p2 - s2.p1, s2.p2 - s2.p1), 0.0));
}

bool isParallel(Vector a, Vector b)
{
	return(equals(cross(a, b), 0.0));
}

bool isParallel(Point a1, Point a2, Point b1, Point b2)
{
	return(isParallel(a1 - a2, b1 - b2));
}

bool isParallel(Segment s1, Segment s2)
{
	return(equals(cross(s1.p1 - s1.p1, s2.p2 - s2.p1), 0.0));
}

int ccw(Point p0, Point p1, Point p2)
{
	Vector a = p1 - p0;
	Vector 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 (a.norm() < b.norm())
	{
		return(ONLINE_FRONT);
	}
	return(ON_SEGMENT);
}

bool intersect(Point p1, Point p2, Point p3, Point p4)
{
	return(ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}

bool intersect(Segment s1, Segment s2)
{
	return(intersect(s1.p1, s1.p2, s2.p1, s2.p2));
}

double getDistance(Point a, Point b)
{
	return((a - b).abs());
}

double getDistanceLP(Line l, Point p)
{
	return(abs((cross(l.p2 - l.p1, p - l.p1) / (l.p2 - l.p1).abs())));
}

double getDistanceSP(Segment s, Point p)
{
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
	{
		return((p - s.p1).abs());
	}
	if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
	{
		return((p - s.p2).abs());
	}
	return(getDistanceLP(s, p));
}

double getDistance(Segment s1, Segment s2)
{
	if (intersect(s1, s2))
	{
		return(0.0);
	}
	return(min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)), min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))));
}

Point getCrossPoint(Segment s1, Segment s2)
{
	Vector base = s2.p2 - s2.p1;
	double d1 = abs(cross(base, s1.p1 - s2.p1));
	double d2 = abs(cross(base, s1.p2 - s2.p1));
	double t = d1 / (d1 + d2);
	return(s1.p1 + (s1.p2 - s1.p1) * t);
}

double arg(Vector p)
{
	return(atan2(p.y, p.x));
}

Vector polar(double a, double r)
{
	return(Point(cos(r) * a, sin(r) * a));
}

pair<Point, Point> getCrossPoints(Circle c1, Circle c2)
{
	double d = (c1.c - c2.c).abs();
	double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
	double t = arg(c2.c - c1.c);
	return(make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a)));
}

pair<Point, Point> getCrossPoints(Circle c, Line l)
{
	Vector pr = project(l, c.c);
	Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
	double base = sqrt(c.r * c.r - (pr - c.c).norm());
	return(make_pair(pr - e * base, pr + e * base));
}

bool inc(Point p1, Point p2, Point p3, Point p4)
{
	Point e0 = p1 - p4;
	Point e1 = p2 - p4;
	Point e2 = p3 - p4;
	long double d0 = cross(e0, e1);
	long double d1 = cross(e1, e2);
	long double d2 = cross(e2, e0);
	if (d0 * d1 > 0 && d1 * d2 > 0 && d2 * d0 > 0)
	{
		return(true);
	}
	return(false);
}

void solve()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	Point p1;
	while (cin >> p1.x >> p1.y, p1.x || p1.y)
	{
		Point p2, p3, p4;
		int r;
		cin >> p2.x >> p2.y >> p3.x >> p3.y >> p4.x >> p4.y >> r;
		
		if (r - getDistance(p4, p1) > 0 && r - getDistance(p4, p2) > 0 && r - getDistance(p4, p3) > 0)
		{
			cout << "b" << endl;
		}
		else if (inc(p1, p2, p3, p4) && getDistanceSP(Segment(p1, p2), p4) - r >= 0 && getDistanceSP(Segment(p1, p3), p4) - r >= 0 && getDistanceSP(Segment(p2, p3), p4) - r >= 0)
		{
			cout << "a" << endl;
		}
		else if (inc(p1, p2, p3, p4) == false && getDistanceSP(Segment(p1, p2), p4) - r > 0 && getDistanceSP(Segment(p1, p3), p4) - r > 0 && getDistanceSP(Segment(p2, p3), p4) - r > 0)
		{
			cout << "d" << endl;
		}
		else
		{
			cout << "c" << endl;
		}
	}
}

int main()
{
	solve();
	return(0);
}