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 <stdio.h>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>

using namespace std;

#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) (EQ((a).real(),(b).real()) && EQ((a).imag(),(b).imag()))

typedef complex<double> P;
typedef long long ll;

const int MAX_SIZE = 10000;

// àÏ
double dot(P a, P b) {
  return (a.real() * b.real() + a.imag() * b.imag());
}
// OÏ
double cross(P a, P b) {
  return (a.real() * b.imag() - a.imag() * b.real());
}
// _cª¼üabãÉ é©È¢©
int is_point_on_line(P a, P b, P c) {
  return EQ( cross(b-a, c-a), 0.0 );
}
// 2¼üÌ¼s»è
int is_orthogonal(P a1, P a2, P b1, P b2) {
  return EQ( dot(a1-a2, b1-b2), 0.0 );
}
// 2¼üÌ½s»è
int is_parallel(P a1, P a2, P b1, P b2) {
  return EQ( cross(a1-a2, b1-b2), 0.0 );
}
// _a,bðÊé¼üÆ_cÌÔÌ£
double distance_l_p(P a, P b, P c) {
  return abs(cross(b-a, c-a)) / abs(b-a);
}
// _a,bð[_Æ·éüªÆ_cÆÌ£
double distance_ls_p(P a, P b, P c) {
  if ( dot(b-a, c-a) < EPS ) return abs(c-a);
  if ( dot(a-b, c-b) < EPS ) return abs(c-b);
  return abs(cross(b-a, c-a)) / abs(b-a);
}
// a1,a2ð[_Æ·éüªÆb1,b2ð[_Æ·éüªÌð·»è
int is_intersected_ls(P a1, P a2, P b1, P b2) {
  return ( cross(a2-a1, b1-a1) * cross(a2-a1, b2-a1) < EPS ) &&
         ( cross(b2-b1, a1-b1) * cross(b2-b1, a2-b1) < EPS );
}
// a1,a2ð[_Æ·éüªÆb1,b2ð[_Æ·éüªÌð_vZ
P intersection_ls(P a1, P a2, P b1, P b2) {
  P b = b2-b1;
  double d1 = abs(cross(b, a1-b1));
  double d2 = abs(cross(b, a2-b1));
  double t = d1 / (d1 + d2);

  return a1 + (a2-a1) * t;
}
// a1,a2ðÊé¼üÆb1,b2ðÊé¼üÌð·»è
int is_intersected_l(P a1, P a2, P b1, P b2) {
  return !EQ( cross(a1-a2, b1-b2), 0.0 );
}
// a1,a2ðÊé¼üÆb1,b2ðÊé¼üÌð_vZ
P intersection_l(P a1, P a2, P b1, P b2) {
  P a = a2 - a1; P b = b2 - b1;
  return a1 + a * cross(b, b1-a1) / cross(b, a);
}
/*
~üÆüªÌð·»è
*/
bool isCircleCrossLine(P a,P b,P c,double r){
	double d1 = abs(a-c);
	double d2 = abs(b-c);
	if(d1<r&&d2<r){
		return false;
	}
	double d = distance_ls_p(a,b,c);
	if(EQ(d,r)||d<r){
		return true;
	}
	else
		return false;
}
// Op`ÌàÉ_ª é©Ç¤©
// OÏÌ³ª·×Ä¯¶ÈçàÉ_ è
bool isInTriangle(P p1,P p2,P p3,P s){
	P a=p1-s;
	P b=p2-s;
	P c=p3-s;
	return (((cross(a,b)>0||EQ(0,cross(a,b)))&&(cross(b,c)>=0||EQ(0,cross(b,c)))&&(cross(c,a)>=0||EQ(0,cross(a,b))))
		||(cross(a,b)<0&&cross(b,c)<0&&cross(c,a)<0));
}

struct Circle{
	double x,y,r;
};

struct Triangle{
	complex<double> p[3];
};

int main(){

	Circle c;
	Triangle t;
	while(1){
		bool f=false;
		for(int i = 0; i < 3; i++){
			int x,y;
			cin>>x>>y;
			if(x==0&&y==0){
				f=true;
				break;
			}
			t.p[i]=complex<double>(x,y);
		}
		if(f)
			break;
		cin>>c.x>>c.y>>c.r;
		// vZ
		// Op`ð\¬·éR_ªÆàÉ~ÌàÉ éÈçÎAOp`Í~ÉÜÜêé
		if(((t.p[0].real()-c.x)*(t.p[0].real()-c.x)+(t.p[0].imag()-c.y)*(t.p[0].imag()-c.y)<c.r*c.r||EQ((t.p[0].real()-c.x)*(t.p[0].real()-c.x)+(t.p[0].imag()-c.y)*(t.p[0].imag()-c.y),c.r*c.r))
			&&((t.p[1].real()-c.x)*(t.p[1].real()-c.x)+(t.p[1].imag()-c.y)*(t.p[1].imag()-c.y)<c.r*c.r||EQ((t.p[1].real()-c.x)*(t.p[1].real()-c.x)+(t.p[1].imag()-c.y)*(t.p[1].imag()-c.y),c.r*c.r))
			&&((t.p[2].real()-c.x)*(t.p[2].real()-c.x)+(t.p[2].imag()-c.y)*(t.p[2].imag()-c.y)<c.r*c.r||EQ((t.p[2].real()-c.x)*(t.p[2].real()-c.x)+(t.p[2].imag()-c.y)*(t.p[2].imag()-c.y),c.r*c.r))
			){
				cout<<"b"<<endl;
		}
		// 3üªÆ~ÌSÌ£ªÇêàrÈãÅ èA©Â~Ì_ªOp`ÌàÉ¶Ý·éÈçÎA~ÍOp`ÉÜÜêé
		else if((distance_ls_p(t.p[0],t.p[1],P(c.x,c.y))>c.r||EQ(distance_ls_p(t.p[0],t.p[1],P(c.x,c.y)),c.r))
			&&(distance_ls_p(t.p[1],t.p[2],P(c.x,c.y))>c.r||EQ(distance_ls_p(t.p[1],t.p[2],P(c.x,c.y)),c.r))
			&&(distance_ls_p(t.p[2],t.p[0],P(c.x,c.y))>c.r||EQ(distance_ls_p(t.p[2],t.p[0],P(c.x,c.y)),c.r))){
			if(isInTriangle(t.p[0],t.p[1],t.p[2],P(c.x,c.y))){
				cout<<"a"<<endl;
			}
			// ~ÌSªOp`ÌÉ¶ÝµÈ¢ê
			else{
				cout<<"d"<<endl;
			}
		}
		// ~ªOp`ÉÜÜê¸A©ÂO_ÆàÉ~ÌOÉ éÈçÎAOp`Æ~Ì¤ÊªÍÈ¢
		//else if((t.p[0].real()-c.x)*(t.p[0].real()-c.x)+(t.p[0].imag()-c.y)*(t.p[0].imag()-c.y)>c.r*c.r
		//	&&(t.p[1].real()-c.x)*(t.p[1].real()-c.x)+(t.p[1].imag()-c.y)*(t.p[1].imag()-c.y)>c.r*c.r
		//	&&(t.p[2].real()-c.x)*(t.p[2].real()-c.x)+(t.p[2].imag()-c.y)*(t.p[2].imag()-c.y)>c.r*c.r){
		//		cout<<"d"<<endl;
		//}
		else{
			cout<<"c"<<endl;
		}
	}

	return 0;
}