#include <iostream>
#include <algorithm>
#include <cmath>
#include <complex>
#include <vector>
using namespace std;

typedef complex<double> P;
typedef vector<P> G;
const double eps = 1e-10;

bool equals(double a, double b) { return fabs(a-b) < eps; }
double dot(P a, P b) { return a.real()*b.real() + a.imag()*b.imag(); }
double norm(P a) { return dot(a,a); }
double abs(P a) { return sqrt(norm(a)); }
double cross(P a, P b) { return a.real()*b.imag() - a.imag()*b.real(); }

double getDistanceLP(P s1, P s2, P p) {
  return fabs(cross(s2 - s1, p - s1)/abs(s2 - s1));
}

double getDistanceSP(P s1, P s2, P p) {
  if(dot(s2 - s1, p - s1) < 0.0) return abs(p - s1);
  if(dot(s1 - s2, p - s2) < 0.0) return abs(p - s2);
  return getDistanceLP(s1, s2, p);
}


int ccw(P p0, P a, P b) {
  a -= p0;
  b -= p0;
  if(cross(a, b) > eps) return 1;
  if(cross(a, b) < -eps) return -1;
  if(dot(a, b) < -eps) return 2;
  if(norm(a) < norm(b)) return -2;
  return 0;
}

G tri;
P co;
double R;


bool isInC(P t, P p, double r) {
  double d = norm(t - p);
  return equals(d, r*r) || d < r*r;
}

bool isInC(G g, P p, double r) {
  for(int i = 0; i < g.size(); ++i) {
    if(!isInC(g[i],p,r)) return false;
  }
  return true;
}

bool isInG(P t, G g) {
  int n = g.size();
  for(int i = 0; i < n; ++i) {
    if(ccw(g[i], g[(i+1)%n], t) == -1) return false;
  }
  return true;
}

bool isInG(P t, double r, G g) {
  if(!isInG(t, g)) return false;
  int n = g.size();
  for(int i = 0; i < n; ++i) {
    double d = getDistanceLP(g[i], g[(i+1)%n], t);
    if(equals(d, r)) continue;
    if(d < r) return false;
  }
  return true;
}

bool isIntersect(P t, double r, G g) {
  int n = g.size();
  for(int i = 0; i < n; ++i) {
    double d = getDistanceSP(g[i], g[(i+1)%n], t);
    if(equals(d, r) || d < r) return true;
  }
  return false;
}

char solve() {
  if(isInC(tri, co, R)) return 'b';
  if(isInG(co, R, tri)) return 'a';
  if(isIntersect(co, R, tri)) return 'c';
  return 'd';
}

int main() {
  P p;
  while(cin >> p.real() >> p.imag()
	&& (p.real() || p.imag())) {
    tri.clear();
    tri.push_back(p);
    for(int i = 1; i < 3; ++i) {
      cin >> p.real() >> p.imag();
      tri.push_back(p);
    }
    if(ccw(tri[0], tri[1], tri[2]) == -1) {
      swap(tri[0], tri[1]);
    }
    cin >> co.real() >> co.imag();
    cin >> R;
    cout << solve() << endl;
  }
  return 0;
}