#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <queue>
using namespace std;

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

const double EPS = 1e-8;
const double INF = 1e12;
typedef complex<double> P;
namespace std {
  bool operator < (const P& a, const P& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
struct L : public vector<P> {
  L() {}
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
};
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
typedef  vector<P> polygon;
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
enum { OUT, ON, IN };
int contains(const polygon& Po, const P& p) {
  bool in = false;
  for (int i = 0; i < Po.size(); ++i) {
    P a = curr(Po,i) - p, b = next(Po,i) - p;
    if (imag(a) > imag(b)) swap(a, b);
    if (imag(a) <= 0 && 0 < imag(b))
      if (cross(a, b) < 0) in = !in;
    if (cross(a, b) == 0 && dot(a, b) <= 0) return ON;
  }
  return in ? IN : OUT;
}
int main() {
  while(1) {
    P p[3];
    bool f=0;
    REP(i,3) {
      int x, y;
      cin >> x >> y;
      if (x==0&&y==0){ f=1;break;}
      p[i] = P(x,y);
    }
    if (f) break;
    P c;
    int x, y;
    cin >> x >> y;
    c = P(x,y);
    double r;
    cin >> r;

    polygon Po;
    REP(i,3) {
      Po.push_back(p[i]);
    }
    L l[3];
    REP(i,3)
      l[i] = L(p[i], p[(i+1)%3]);
    double d[3];
    REP(i,3) {
      d[i] = distanceSP(l[i], c);
    }
    if (abs(p[0]-c) < r+EPS && abs(p[1]-c) < r+EPS && abs(p[2]-c) < r+EPS) {
      cout << "b" << endl;
    } else if (contains(Po, c) == IN && d[0] > r-EPS && d[1] > r-EPS && d[2] > r-EPS) {
      cout << "a" << endl;
    } else if (d[0] < r+EPS || d[1] < r+EPS || d[2] < r+EPS) {
      cout << "c" << endl;
    } else
      cout << "d" << endl;
  }

}