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 JAVA):

Solution:
import static java.util.Arrays.*;
import static java.lang.Math.*;
import static java.math.BigInteger.*;
import java.util.*;
import java.math.*;
import java.io.*;

public class newD implements Runnable
{
    String file = "input";
    
    void init() throws IOException
    {
        //input = new BufferedReader(new FileReader(file + ".in"));
        input = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new BufferedOutputStream(System.out));
    }
    
    void solve() throws IOException
    {
        int runs = nextInt();
        while(runs-- > 0)
        {
            Point[] p = new Point[3];
            for(int i = 0; i < 3; i++) p[i] = new Point(nextInt(), nextInt());
            
            if(solve(p[0], p[1], p[2]) || solve(p[1], p[2], p[0]) || solve(p[2], p[0], p[1]));
            else out.println("NO\n");
        }
    }
    
    double EPS = 1e-9;
    
    boolean solve(Point m, Point n, Point p)
    {
        Point q = m.mul(2).sub(p);
        Point b = center(m, n, q);
        if(b == null) return false;
        
        Point a = n.mul(2).sub(b);
        Point c = m.mul(2).sub(b);
        Point d = p.mul(2).sub(c);
        
        if(convex(new Point[] {a, b, c, d}))
        {
            out.println("YES");
            out.printf("%.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f\n", a.x, a.y, b.x, b.y, c.x, c.y, d.x, d.y);
            return true;
        }
        return false;
    }
    
    boolean convex(Point[] p)
    {
        int n = p.length;
        if(n <= 2) return false;
        
        double sign = p[1].sub(p[0]).cross(p[2].sub(p[0]));
        if(abs(sign) < EPS) return false;
        
        for(int i = 1; i < n; i++)
        {
            double cur = p[(i + 1) % n].sub(p[i]).cross(p[(i + 2) % n].sub(p[i]));
            if(cur * sign <= 0) return false;
        }
        return true;
    }
    
    double[] line(Point p, Point q)
    {
        double a = p.y - q.y;
        double b = q.x - p.x;
        double c = p.x * q.y - p.y * q.x;
        return new double[] {a, b, c};
    }
    
    Point center(Point a, Point b, Point c)
    {
        double[] c1 = line(a, b);
        Point d = a.add(b).div(2);
        
        double[] c2 = line(b, c);
        Point e = b.add(c).div(2);
        
        Point o = intersection(-c1[1], c1[0], c1[1] * d.x - c1[0] * d.y, -c2[1], c2[0], c2[1] * e.x - c2[0] * e.y);
        return o;
    }
    
    Point intersection(double a1, double b1, double c1, double a2, double b2, double c2)
    {
        double det = a1 * b2 - a2 * b1;
        if(abs(det) < EPS) return null;
        double x = (b1 * c2 - b2 * c1) / det;
        double y = (c1 * a2 - c2 * a1) / det;
        return new Point(x, y);
    }
    
    class Point
    {
        double x, y;
        
        Point(double x, double y)
        {
            this.x = x;
            this.y = y;
        }
        
        Point add(Point p)
        {
            return new Point(x + p.x, y + p.y);
        }
        
        Point sub(Point p)
        {
            return new Point(x - p.x, y - p.y);
        }
        
        Point mul(double k)
        {
            return new Point(x * k, y * k);
        }
        
        Point div(double k)
        {
            return new Point(x / k, y / k);
        }
        
        double dist()
        {
            return sqrt(dist2());
        }
        
        double dist2()
        {
            return x * x + y * y;
        }
        
        double dot(Point p)
        {
            return x * p.x + y * p.y;
        }
        
        double cross(Point p)
        {
            return x * p.y - y * p.x;
        }
        
        public String toString()
        {
            return String.format("(%.2f, %.2f)", x, y);
        }
    }
    
    
    String next() throws IOException
    {
        while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(input.readLine());
        return st.nextToken();
    }
    
    int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }
    
    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }
    
    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }
    
    void print(Object... o)
    {
        System.out.println(deepToString(o));
    }
    
    void gcj(Object o)
    {
        String s = String.valueOf(o);
        out.println("Case #" + test + ": " + s);
        System.out.println("Case #" + test + ": " + s);
    }
    
    BufferedReader input;
    PrintWriter out;
    StringTokenizer st;
    int test;
    
    public static void main(String[] args) throws IOException
    {
        new Thread(null, new newD(), "", 1 << 20).start();
    }
    
    public void run()
    {
        try
        {
            init();
            solve();
            out.close();        
        }
        catch(Exception e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }
}