Problem: You're given the centers of three equal sides of a strictly convex tetragon. Your task is to restore the initial tetragon.

Input

The first input line contains one number T — amount of tests (1 ≤ T ≤ 5·104). Each of the following T lines contains numbers x1, y1, x2, y2, x3, y3 — coordinates of different points that are the centers of three equal sides (non-negative integer numbers, not exceeding 10).

Output

For each test output two lines. If the required tetragon exists, output in the first line YES, in the second line — four pairs of numbers — coordinates of the polygon's vertices in clockwise or counter-clockwise order. Don't forget, please, that the tetragon should be strictly convex, i.e. no 3 of its points lie on one line. Output numbers with 9 characters after a decimal point.

If the required tetragon doen't exist, output NO in the first line, and leave the second line empty.

Examples

Input

3
1 1 2 2 3 3
0 1 1 0 2 2
9 3 7 9 9 8


Output

NO

YES
3.5 1.5 0.5 2.5 -0.5 -0.5 2.5 0.5
NO

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
double EPS = 1e-9;
struct PT {
  double x, y;
  double length() { return sqrt(x * x + y * y); }
  int normalize() {
    double l = length();
    if (fabs(l) < EPS) return -1;
    x /= l;
    y /= l;
    return 0;
  }
  PT operator-(PT a) {
    PT r;
    r.x = x - a.x;
    r.y = y - a.y;
    return r;
  }
  PT operator+(PT a) {
    PT r;
    r.x = x + a.x;
    r.y = y + a.y;
    return r;
  }
  PT operator*(double sc) {
    PT r;
    r.x = x * sc;
    r.y = y * sc;
    return r;
  }
};
bool operator<(const PT& a, const PT& b) {
  if (fabs(a.x - b.x) < EPS) return a.y < b.y;
  return a.x < b.x;
}
double dist(PT& a, PT& b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double dot(PT& a, PT& b) { return (a.x * b.x + a.y * b.y); }
int sideSign(PT& p1, PT& p2, PT& p3) {
  double sg = (p1.x - p3.x) * (p2.y - p3.y) - (p1.y - p3.y) * (p2.x - p3.x);
  if (fabs(sg) < EPS) return 0;
  if (sg > 0) return 1;
  return -1;
}
bool better(PT& p1, PT& p2, PT& p3) {
  double sg = (p1.y - p3.y) * (p2.x - p3.x) - (p1.x - p3.x) * (p2.y - p3.y);
  if (fabs(sg) < EPS) {
    if (dist(p3, p1) > dist(p3, p2))
      return true;
    else
      return false;
  }
  if (sg < 0) return true;
  return false;
}
void vex(vector<PT>& vin, vector<PT>& vout) {
  vout.clear();
  int n = vin.size();
  int st = 0;
  int i;
  for (i = 1; i < n; i++)
    if (vin[i] < vin[st]) st = i;
  vector<int> used;
  used.push_back(st);
  int idx = st;
  int next;
  do {
    next = 0;
    for (i = 1; i < n; i++)
      if (better(vin[i], vin[next], vin[idx])) next = i;
    idx = next;
    used.push_back(idx);
  } while (idx != st);
  for (i = 0; i + 1 < (int)used.size(); i++) vout.push_back(vin[used[i]]);
}
void vex2(vector<PT> vin, vector<PT>& vout) {
  vout.clear();
  int n = vin.size();
  sort(vin.begin(), vin.end());
  PT stk[1000];
  int pstk, i;
  stk[0] = vin[0];
  stk[1] = vin[1];
  pstk = 2;
  for (i = 2; i < n; i++) {
    if (dist(vin[i], vin[i - 1]) < EPS) continue;
    while (pstk > 1 && better(vin[i], stk[pstk - 1], stk[pstk - 2])) pstk--;
    stk[pstk] = vin[i];
    pstk++;
  }
  for (i = 0; i < pstk; i++) vout.push_back(stk[i]);
  for (i = 0; i < n; i++) {
    vin[i].y = -vin[i].y;
    vin[i].x = -vin[i].x;
  }
  sort(vin.begin(), vin.end());
  stk[0] = vin[0];
  stk[1] = vin[1];
  pstk = 2;
  for (i = 2; i < n; i++) {
    if (dist(vin[i], vin[i - 1]) < EPS) continue;
    while (pstk > 1 && better(vin[i], stk[pstk - 1], stk[pstk - 2])) pstk--;
    stk[pstk] = vin[i];
    pstk++;
  }
  for (i = 1; i < pstk - 1; i++) {
    stk[i].x = -stk[i].x;
    stk[i].y = -stk[i].y;
    vout.push_back(stk[i]);
  }
}
int isConvex(vector<PT>& v) {
  int i, j, k;
  int c1 = 0;
  int c2 = 0;
  int c0 = 0;
  int n = v.size();
  for (i = 0; i < n; i++) {
    j = (i + 1) % n;
    k = (j + 1) % n;
    int s = sideSign(v[i], v[j], v[k]);
    if (s == 0) c0++;
    if (s > 0) c1++;
    if (s < 0) c2++;
  }
  if (c1 && c2) return 0;
  if (c0) return 2;
  return 1;
}
double trap(PT a, PT b) { return (0.5 * (b.x - a.x) * (b.y + a.y)); }
double area(vector<PT>& vin) {
  int n = vin.size();
  double ret = 0.0;
  for (int i = 0; i < n; i++) ret += trap(vin[i], vin[(i + 1) % n]);
  return fabs(ret);
}
double peri(vector<PT>& vin) {
  int n = vin.size();
  double ret = 0.0;
  for (int i = 0; i < n; i++) ret += dist(vin[i], vin[(i + 1) % n]);
  return ret;
}
double triarea(PT a, PT b, PT c) {
  return fabs(trap(a, b) + trap(b, c) + trap(c, a));
}
double height(PT a, PT b, PT c) {
  double s3 = dist(c, b);
  double ar = triarea(a, b, c);
  return (2.0 * ar / s3);
}
int intersection(PT p1, PT p2, PT p3, PT p4, PT& r) {
  double d = (p4.y - p3.y) * (p2.x - p1.x) - (p4.x - p3.x) * (p2.y - p1.y);
  if (fabs(d) < EPS) return -1;
  double ua;
  ua = (p4.x - p3.x) * (p1.y - p3.y) - (p4.y - p3.y) * (p1.x - p3.x);
  ua /= d;
  r = p1 + (p2 - p1) * ua;
  return 0;
}
void closestpt(PT p1, PT p2, PT p3, PT& r) {
  if (fabs(triarea(p1, p2, p3)) < EPS) {
    r = p3;
    return;
  }
  PT v = p2 - p1;
  v.normalize();
  double pr;
  pr = (p3.y - p1.y) * v.y + (p3.x - p1.x) * v.x;
  r = p1 + v * pr;
}
int hcenter(PT p1, PT p2, PT p3, PT& r) {
  if (triarea(p1, p2, p3) < EPS) return -1;
  PT a1, a2;
  closestpt(p2, p3, p1, a1);
  closestpt(p1, p3, p2, a2);
  intersection(p1, a1, p2, a2, r);
  return 0;
}
int center(PT p1, PT p2, PT p3, PT& r) {
  if (triarea(p1, p2, p3) < EPS) return -1;
  PT a1, a2, b1, b2;
  a1 = (p2 + p3) * 0.5;
  a2 = (p1 + p3) * 0.5;
  b1.x = a1.x - (p3.y - p2.y);
  b1.y = a1.y + (p3.x - p2.x);
  b2.x = a2.x - (p3.y - p1.y);
  b2.y = a2.y + (p3.x - p1.x);
  intersection(a1, b1, a2, b2, r);
  return 0;
}
int bcenter(PT p1, PT p2, PT p3, PT& r) {
  if (triarea(p1, p2, p3) < EPS) return -1;
  double s1, s2, s3;
  s1 = dist(p2, p3);
  s2 = dist(p1, p3);
  s3 = dist(p1, p2);
  double rt = s2 / (s2 + s3);
  PT a1, a2;
  a1 = p2 * rt + p3 * (1.0 - rt);
  rt = s1 / (s1 + s3);
  a2 = p1 * rt + p3 * (1.0 - rt);
  intersection(a1, p1, a2, p2, r);
  return 0;
}
double angle(PT& p1, PT& p2, PT& p3) {
  PT va = p2 - p1;
  va.normalize();
  PT vb;
  vb.x = -va.y;
  vb.y = va.x;
  PT v = p3 - p1;
  double x, y;
  x = dot(v, va);
  y = dot(v, vb);
  return (atan2(y, x));
}
double angle(double a, double b, double c) {
  double cs = (b * b + c * c - a * a) / (2.0 * b * c);
  return (acos(cs));
}
void rotate(PT p0, PT p1, double a, PT& r) {
  p1 = p1 - p0;
  r.x = cos(a) * p1.x - sin(a) * p1.y;
  r.y = sin(a) * p1.x + cos(a) * p1.y;
  r = r + p0;
}
void reflect(PT& p1, PT& p2, PT p3, PT& r) {
  if (dist(p1, p3) < EPS) {
    r = p3;
    return;
  }
  double a = angle(p1, p2, p3);
  r = p3;
  rotate(p1, r, -2.0 * a, r);
}
int pAndSeg(PT& p1, PT& p2, PT& p) {
  double s = triarea(p, p1, p2);
  if (s > EPS) return (0);
  double sg = (p.x - p1.x) * (p.x - p2.x);
  if (sg > EPS) return (-1);
  sg = (p.y - p1.y) * (p.y - p2.y);
  if (sg > EPS) return (-1);
  return (1);
}
int lineAndCircle(PT& oo, double r, PT& p1, PT& p2, PT& r1, PT& r2) {
  PT m;
  closestpt(p1, p2, oo, m);
  PT v = p2 - p1;
  v.normalize();
  double r0 = dist(oo, m);
  if (r0 > r + EPS) return -1;
  if (fabs(r0 - r) < EPS) {
    r1 = r2 = m;
    return 1;
  }
  double dd = sqrt(r * r - r0 * r0);
  r1 = m - v * dd;
  r2 = m + v * dd;
  return 0;
}
int CAndC(PT o1, double r1, PT o2, double r2, PT& q1, PT& q2) {
  double r = dist(o1, o2);
  if (r1 < r2) {
    swap(o1, o2);
    swap(r1, r2);
  }
  if (r < EPS) return (-1);
  if (r > r1 + r2 + EPS) return (-1);
  if (r < r1 - r2 - EPS) return (-1);
  PT v = o2 - o1;
  v.normalize();
  q1 = o1 + v * r1;
  if (fabs(r - r1 - r2) < EPS || fabs(r + r2 - r1) < EPS) {
    q2 = q1;
    return (1);
  }
  double a = angle(r2, r, r1);
  q2 = q1;
  rotate(o1, q1, a, q1);
  rotate(o1, q2, -a, q2);
  return 0;
}
int pAndPoly(vector<PT> pv, PT p) {
  int i, j;
  int n = pv.size();
  pv.push_back(pv[0]);
  for (i = 0; i < n; i++)
    if (pAndSeg(pv[i], pv[i + 1], p) == 1) return (-1);
  for (i = 0; i < n; i++) pv[i] = pv[i] - p;
  p.x = p.y = 0.0;
  double a, y;
  while (1) {
    a = (double)rand() / 10000.00;
    j = 0;
    for (i = 0; i < n; i++) {
      rotate(p, pv[i], a, pv[i]);
      if (fabs(pv[i].x) < EPS) j = 1;
    }
    if (j == 0) {
      pv[n] = pv[0];
      j = 0;
      for (i = 0; i < n; i++)
        if (pv[i].x * pv[i + 1].x < -EPS) {
          y = pv[i + 1].y -
              pv[i + 1].x * (pv[i].y - pv[i + 1].y) / (pv[i].x - pv[i + 1].x);
          if (y > 0) j++;
        }
      return (j % 2);
    }
  }
  return 1;
}
void show(PT& p) { cout << "(" << p.x << ", " << p.y << ")" << endl; }
void show(vector<PT>& p) {
  int i, n = p.size();
  for (i = 0; i < n; i++) show(p[i]);
  cout << ":)" << endl;
}
void cutPoly(vector<PT>& pol, PT& p1, PT& p2, vector<PT>& pol1,
             vector<PT>& pol2) {
  vector<PT> pp, pn;
  pp.clear();
  pn.clear();
  int i, sg, n = pol.size();
  PT q1, q2, r;
  for (i = 0; i < n; i++) {
    q1 = pol[i];
    q2 = pol[(i + 1) % n];
    sg = sideSign(p1, p2, q1);
    if (sg >= 0) pp.push_back(q1);
    if (sg <= 0) pn.push_back(q1);
    if (intersection(p1, p2, q1, q2, r) >= 0) {
      if (pAndSeg(q1, q2, r) == 1) {
        pp.push_back(r);
        pn.push_back(r);
      }
    }
  }
  pol1.clear();
  pol2.clear();
  if (pp.size() > 2) vex2(pp, pol1);
  if (pn.size() > 2) vex2(pn, pol2);
}
int PInterP(vector<PT>& p1, vector<PT>& p2, vector<PT>& p3) {
  vector<PT> pts;
  PT pp;
  pts.clear();
  int m = p1.size();
  int n = p2.size();
  int i, j;
  for (i = 0; i < m; i++)
    if (pAndPoly(p2, p1[i]) != 0) pts.push_back(p1[i]);
  for (i = 0; i < n; i++)
    if (pAndPoly(p1, p2[i]) != 0) pts.push_back(p2[i]);
  if (m > 1 && n > 1)
    for (i = 0; i < m; i++)
      for (j = 0; j < n; j++)
        if (intersection(p1[i], p1[(i + 1) % m], p2[j], p2[(j + 1) % n], pp) ==
            0) {
          if (pAndSeg(p1[i], p1[(i + 1) % m], pp) != 1) continue;
          if (pAndSeg(p2[j], p2[(j + 1) % n], pp) != 1) continue;
          pts.push_back(pp);
        }
  if (pts.size() <= 1) {
    p3.resize(1);
    p3[0].x = p3[0].y = 0.0;
    return (1);
  }
  vex2(pts, p3);
  return (0);
}
PT arr[7];
bool f(int i, int j, int k) {
  bool flag = i == 2 and !j and k == 1;
  PT X = arr[i], Y = arr[j], Z = arr[k];
  PT aux;
  rotate(Y, Z, PI, aux);
  center(X, Y, aux, arr[4]);
  rotate(X, arr[4], PI, arr[3]);
  rotate(Y, arr[4], PI, arr[5]);
  rotate(Z, arr[5], PI, arr[6]);
  int s = sideSign(arr[5], arr[6], arr[3]);
  if (!s) return false;
  if (sideSign(arr[6], arr[3], arr[4]) != s or
      sideSign(arr[3], arr[4], arr[5]) != s or
      sideSign(arr[4], arr[5], arr[6]) != s)
    return false;
  double l = (arr[4] - arr[3]).length();
  for (int i = 4; i < 7; i++) {
    double d = (arr[i] - arr[i - 1]).length();
    if (abs(d - l) > EPS) return false;
  }
  return true;
}
void solve() {
  for (int i = 0; i < 3; i++) scanf("%lf %lf", &arr[i].x, &arr[i].y);
  if (f(0, 1, 2) or f(0, 2, 1) or f(1, 0, 2) or f(1, 2, 0) or f(2, 0, 1) or
      f(2, 1, 0)) {
    printf("YES\n");
    for (int i = 3; i < 7; i++) printf("%.9f %.9f ", arr[i].x, arr[i].y);
    printf("\n");
  } else
    printf("NO\n\n");
}
int main() {
  int t;
  scanf("%d", &t);
  while (t--) solve();
  return 0;
}