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<cmath>
#include<vector>
#include<algorithm>
using namespace std;

enum POSITION {UNDER = -1, ON, ABOVE};

// classes
class Point;
class Segment;
class Circle;

// members
class Point {
public:
    double x, y;
    Point(double x, double y) :x(x), y(y) {}
    const Point& operator=(const Point& p) {x = p.x; y = p.y; return *this;}
    const Point operator+(const Point& p) const {return Point(x + p.x, y + p.y);}
    const Point operator-(const Point& p) const {return Point(x - p.x, y - p.y);}
    const Point operator*(const Point& p) const {return Point(x * p.x, y * p.y);}
    double distance(const Point& p) const;
    double distance(const Segment& s) const;
    double dot(const Point& p) const;
    double cross(const Point& p) const;
    const Point projection(const Segment& s) const;
};
class Segment {
public:
    Point start, end;
    Segment(const Point& s, const Point& e) :start(s), end(e) {}
    POSITION ccw(const Point& p) const {
        const Point& a = start;
        const Point& b = end;
        Point v1 = b - a;
        Point v2 = p - a;
        double d = v1.cross(v2);
        if(d < 0.0) return ABOVE;
        if(d > 0.0) return UNDER;
        return ON;
    }
};
class Circle {
public:
    Point center;
    double r;
    Circle(double x, double y, double r) :center(Point(x, y)), r(r * r) {}
    bool include(const Point& p) const {return center.distance(p) < r;}
    bool include(const Segment& s) const {return center.distance(s) < r;}
};

// implements
double Point::distance(const Point& p) const {return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y);}
double Point::distance(const Segment& s) const {
    Point p = projection(s);
    if(s.ccw(p) == ON) return distance(p);
    return min(distance(s.start), distance(s.end));
}
double Point::dot(const Point& p) const {return x * p.x - y * p.y;}
double Point::cross(const Point& p) const {return x * p.y - y * p.x;}
const Point Point::projection(const Segment& s) const {
    Point v1 = *this - s.start;
    Point v2 = s.start - s.end;
    double t = v1.dot(v2) / s.start.distance(s.end);
    return s.start + Point(t, t) * v2;
}

// main
string check(const vector<Point>& triangle, const Circle& circle) {
    vector<Segment> edge;
    for(int i = 0; i < 3; ++i) edge.push_back(Segment(triangle[i], triangle[(i + 1) % 3]));

    bool triangleInCircle = true;
    for(auto& p: triangle) triangleInCircle &= circle.include(p);
    if(triangleInCircle) return "b";

    for(auto& e: edge) if(circle.include(e)) return "c";

    int cw = 0, ccw = 0;
    for(auto& e: edge) {
        if(e.ccw(circle.center) >= 0) ++ccw;
        if(e.ccw(circle.center) <= 0) ++cw;
    }
    if(cw == 3 || ccw == 3) return "a";

    return "d";
}

int main() {
    double x[4], y[4], r;
    while(cin >> x[0] >> y[0], x[0] + y[0]) {
        cin >> x[1] >> y[1] >> x[2] >> y[2] >> x[3] >> y[3] >> r;
        vector<Point> triangle = {
            Point(x[0], y[0]),
            Point(x[1], y[1]),
            Point(x[2], y[2]),
        };
        Circle circle(x[3], y[3], r);
        cout << check(triangle, circle) << endl;
    }
}