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 <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>

using namespace std;

#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)

template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
#include <complex>
typedef complex<double> Point;

// 誤差を加味した符号判定
int sign(double a){
  if(a > EPS) return +1;
  if(a < -EPS) return -1;
  return 0;
}

// 誤差を加味した同一判定
bool equal(double a, double b){ 
  return abs(b - a) < EPS;
}
bool operator==(const Point& a, const Point& b){
  return equal(a.real(), b.real()) && equal(a.imag(), b.imag());
}

// 比較演算子
namespace std{
  bool operator < (const Point& a, const Point& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}

// 内積・外積
double dot(Point a, Point b){
  return real(conj(a) * b);
}
double cross(Point a, Point b){
  return imag(conj(a) * b);
}

// 点の回転
Point rotate(Point a, double b){
  return a * polar(1.0, b);
}

// 点の進行方向
int ccw(Point a, Point b, Point c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1; // 反時計回り
  if (cross(b, c) < -EPS)   return -1; // 時計回り
  if (dot(b, c) < 0)     return +2; // c--a--b の順番で一直線上
  if (norm(b) < norm(c)) return -2; // a--b--c の順番で一直線上
  return 0;                         // a--c--b の順番で一直線上(またはb == c)
}

typedef vector<Point> Polygon;

// Polygonの要素へのアクセス
Point curr(const Polygon& a, int x){ return a[x]; }
Point next(const Polygon& a, int x){ return a[(x + 1) % a.size()]; }
Point prev(const Polygon& a, int x){ return a[(x - 1 + a.size()) % a.size()]; }

// 点が多角形のどこにあるのか判定する
enum { OUT, ON, IN };
int contains(const Polygon& P, const Point& p){
  // 点pから半直線をひき、辺と交差する回数を数える
  bool in = false;
  REP(i, P.size()){
    Point a = curr(P, i) - p;
    Point b = next(P, i) - p;
    if(a.imag() > b.imag()) swap(a, b);
    // aからbの直線がy=0と交わり、その交点は原点の右側である
    if(a.imag() <= 0 && 0 < b.imag() && cross(a, b) < 0){ 
      in = !in;
    }
    if(cross(a, b) == 0 && dot(a, b) <= 0) return ON;
  }
  return in ? IN : OUT;
}

// 多角形の面積
double area(const Polygon& P) {
  double A = 0;
  REP(i, P.size()){
    A += cross(curr(P, i), next(P, i));
  }
  return A / 2.0;
}
struct Circle : Point {
  double r;
  Circle() {}
  Circle(Point p, double r) : Point(p), r(r) { }
};

// 円と点の交差判定(EPS注意)
bool containCP(const Circle& c, const Point& p){
  // 円の中心と点の距離が、円の半径以下である
  return sign(abs(c - p) - c.r) <= 0;
}

// 二つの円の交差判定(EPS注意)
bool intersectCC(const Circle& c, const Circle& d){
  // 円の中心同士の距離が、半径の和以下であり、半径の差以上である
  double e = abs(c - d);
  return sign(e - (c.r + d.r)) <= 0 && sign(e - abs(c.r - d.r)) >= 0;
}
struct Line : public vector<Point> {
  Line(const Point& a, const Point& b) {
    push_back(a); push_back(b);
  }
  Point vector() const {
    return back() - front();
  }
};

// 注意: 端点で交わったり重なったりする場合も交差していると判定する(?)

// 二直線の平行判定
bool paralell(const Line& l, const Line& m){
  return sign(cross(l.vector(), m.vector())) == 0;
}

// 二直線の同一判定
bool equalLL(const Line& l, const Line& m){
  return sign(cross(l.vector(), m[0] - l[0])) == 0;
}

// 直線と線分の交差判定
bool intersectLS(const Line& l, const Line& s) {
  // 直線lについて、線分sの端点が異なる側にある
  return sign(cross(l.vector(), s[0] - l[0]) * cross(l.vector(), s[1] - l[0])) <= 0;
}

// 直線と点の交差判定
bool intersectLP(const Line& l, const Point& p) {
  // 直線lとl[0]からpへの直線が平行
  return sign(cross(l.vector(), p - l[0])) == 0;
}

// 二つの線分の交差判定
bool intersectSS(const Line& s, const Line& t) {
  return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) <= 0 &&
         ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) <= 0;
}

// 線分と点の交差判定
bool intersectSP(const Line& s, const Point& p) {
  return ccw(s[0], s[1], p) == 0;
}

// 射影
Point projection(const Line& l, const Point& p){
  double t = dot(p - l[0], l.vector()) / norm(l.vector());
  return l[0] + t * l.vector();
}

// 反射
Point reflection(const Line& l, const Point& p){
  return p + 2.0 * (projection(l, p) - p);
}

// 直線と点の距離
double distanceLP(const Line& l, const Point& p){
  // pからlに下ろした垂線の長さ
  return abs(p - projection(l, p));
}

// 二直線の距離
double distanceLL(const Line& l, const Line& m){
  // 平行でないときは0, 平行のときは垂線の長さ
  return paralell(l, m) ? distanceLP(l, m[0]) : 0;
}

// 直線と線分の距離
double distanceLS(const Line& l, const Line& s){
  if(intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}

// 線分と点の距離
double distanceSP(const Line& s, const Point& p){
  const Point r = projection(s, p);
  if(intersectSP(s, r)) return abs(r - p); // 垂線が線分に交わるとき
  return min(abs(s[0] - p), abs(s[1] - p));
}

// 二つの線分の距離
double distanceSS(const Line& s, const Line& t){
  if(intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}

// 二直線の交点
Point crosspointLL(const Line& l, const Line& m){
  double A = cross(l.vector(), m.vector());
  double B = cross(l.vector(), l[1] - m[0]);
  if(sign(A) == 0 && sign(B) == 0) return m[0]; // 二直線が重なっている
  if(sign(A) == 0) assert(false); // 直線が交わらない
  return m[0] + m.vector() * B / A;
}

string solve(Polygon t, Circle C){
  bool is_b = true;
  REP(i, 3) if(!containCP(C, t[i])) is_b = false;
  if(is_b) return "b";

  if(contains(t, C) == IN){
    REP(i, 3) if(sign(distanceSP(Line(t[i], t[(i + 1) % 3]), C) - C.r) < 0) return "c";
    return "a";
  }else{
    REP(i, 3) if(sign(distanceSP(Line(t[i], t[(i + 1) % 3]), C) - C.r) <= 0) return "c";
    return "d";
  }
}
int main(){
  while(true){
    Polygon t;
    REP(i, 3) {
      double x, y; cin >> x >> y;
      t.push_back(Point(x, y));
    }
    Circle C;
    cin >> C.real() >> C.imag() >> C.r;
    if(cin.eof()) break;
    cout << solve(t, C) << endl;
  }
  return 0;
}