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

typedef complex< double > Point;
typedef complex< double > Vector;
const double kEps = 1e-8;
const double kPi = acos(-1.0);

struct Arc {
  Point p1, p2;
  double r;

  Arc(const Point &rp1, const Point &rp2, double _r) {
    p1 = rp1, p2 = rp2, r = _r;
  }
};

struct Bow {
  Point p1, p2, po;
  double r, alph;

  Bow(const Point &rp1, const Point &rp2, const Point &rpo,
      double _r, double _alph) {
    p1 = rp1, p2 = rp2, po = rpo, r = _r, alph = _alph;
  }
};

string str;
vector< Point > v_pt;
vector< Arc > v_arc;
vector< Bow > v_bow;
Point mg_sum, cntr;
double m_sum;

void read_input(void);
void solve(void);
bool is_in_plyg(void);
bool is_contain(const Bow &, const Point &);

inline double cross(Vector u, Vector v) { return imag(conj(u) * v); }

inline bool fle(double a, double b) { return a < b + kEps; }
inline bool flt(double a, double b) { return a + kEps < b; }

inline int find_quad(Point p) {
  if (flt(imag(p), 0))
    return flt(real(p), 0) ? 2 : 3;
  else
    return flt(real(p), 0) ? 1 : 0;
}

int main() {
  cout.setf(ios::fixed), cout.precision(4);
  while (cin >> str && str != "end") {
    read_input();
    solve();
  }

  return 0;
}

void read_input(void) {
  int x0, y0, xp, yp, xc, yc, r;

  v_pt.clear(), v_arc.clear();

  cin >> x0 >> y0, xp = x0, yp = y0, v_pt.push_back(Point(x0, y0));
  while (cin >> str && str != "close") {
    if (str == "line")
      cin >> xc >> yc;
    else {
      cin >> xc >> yc >> r;
      v_arc.push_back(Arc(Point(xp, yp), Point(xc, yc), r));
    }
    xp = xc, yp = yc;
    v_pt.push_back(Point(xc, yc));
  }
  if (xc != x0 || yc != y0)
    v_pt.push_back(v_pt[0]);

}

void solve(void) {
  mg_sum = Point(0, 0), m_sum = 0, v_bow.clear();

  for (int i = 0; i < v_pt.size() - 1; ++i) {
    double m;
    Point &p1 = v_pt[i], &p2 = v_pt[i + 1], g;
    m = cross(p1, p2) / 2, g = (p1 + p2) / 3.0;
    mg_sum += m * g, m_sum += m;
  }

  for (int i = 0; i < v_arc.size(); ++i) {
    double c, tht, r;
    Point &p1 = v_arc[i].p1, &p2 = v_arc[i].p2, po, g;

    r = v_arc[i].r;
    c = abs(p2 - p1), tht = acos((2 * r * r - c * c) / (2 * r * r));

    double alph = (kPi - tht) / 2 * (r < 0 ? 1 : -1);
    Vector rtv = Vector(cos(alph), sin(alph)), u = p2 - p1;

    po = p1 + u * rtv * abs(r) / c;

    double a = r * r * (tht - sin(tht)) / 2, dy;

    dy = 2 * pow(abs(r), 3.0) * pow(sin(tht / 2), 3.0) / (3.0 * a);
    tht = kPi * (r < 0 ? -1 : 1) / 2;
    g = po + u * Vector(cos(tht), sin(tht)) / abs(u) * dy;
    a *= (r < 0 ? 1 : -1);

    mg_sum += a * g, m_sum += a;
    v_bow.push_back(Bow(p1, p2, po, r, alph));
  }

  cntr = mg_sum / m_sum;
  cout << real(cntr) + kEps << " " << imag(cntr) + kEps << " ";

  bool res = is_in_plyg();

  if (res) {
    for (int i = 0; i < v_bow.size() && res; ++i)
      if (v_bow[i].r > 0 && is_contain(v_bow[i], cntr))
        res = false;
  }
  else {
    for (int i = 0; i < v_bow.size() && !res; ++i)
      if (v_bow[i].r < 0 && is_contain(v_bow[i], cntr))
        res = true;
  }

  cout << (res ? "+" : "-") << "\n";
}

bool is_in_plyg(void) {
  vector< Point > tmp = v_pt;
  int cnt = 0;

  for (int i = 0; i < tmp.size(); ++i)
    tmp[i] -= cntr;

  for (int i = 0; i < tmp.size() - 1; ++i) {
    Point &p1 = tmp[i], &p2 = tmp[i + 1];
    int qa = find_quad(p1), qb = find_quad(p2);

    if ((qa + 1) % 4 == qb)
      ++cnt;
    else if ((qa + 3) % 4 == qb)
      --cnt;
    else if ((qa + 2) % 4 == qb) {
      if (fle(0, cross(p1, p2)))
        cnt += 2;
      else
        cnt -= 2;
    }
  }

  return cnt != 0;
}

bool is_contain(const Bow &rb, const Point &rp) {
  Point p1, p2, po;
  double r, alph, crs1, crs2, d, dp;

  p1 = rb.p1, p2 = rb.p2, po = rb.po, r = rb.r, alph = rb.alph;
  crs1 = cross(p1 - po, rp - po), crs2 = cross(rp - po, p2 - po);
  d = abs(r) * sin(abs(alph)), dp = abs(rp - po);

  return flt(crs1 * r, 0) && flt(crs2 * r, 0) && fle(d, dp) && fle(dp, abs(r));
}

Measured memory_bytes: 1432