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
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;
		
		if(sign > EPS) sign = 1;
		else sign = -1;
		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 < EPS) 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);
		}
	}
}