import java.io.*;
import java.util.*;

public class trenches_at implements Runnable {
	BufferedReader in;
	StringTokenizer st;
	PrintWriter out;
	
	class Point {
		public int x, y;
		
		Point () throws Exception {
			x = nextInt();
			y = nextInt();
		}
		
		Point (int x, int y) {
			this.x = x;
			this.y = y;
		}
		
		public boolean isEmpty () {
			if (x == 0 && y == 0) {
				return true;
			}
			return false;
		}
		
		public int distTo(Point other) {
			return (this.x - other.x) * (this.x - other.x) + (this.y - other.y) * (this.y - other.y); 
		}
	}
	
	public boolean isSolution(int a, int b, int c, Point p1, Point p2, Point p3, Point p4) {
		if (a * p1.x + b * p1.y + c > 0 && a * p2.x + b * p2.y + c > 0) {
			if (a * p3.x + b * p3.y + c < 0 && a * p4.x + b * p4.y + c < 0) {
				return true;
			}
			return false;
		}
		if (a * p1.x + b * p1.y + c < 0 && a * p2.x + b * p2.y + c < 0) {
			if (a * p3.x + b * p3.y + c > 0 && a * p4.x + b * p4.y + c > 0) {
				return true;
			}
			return false;
		}
		return false;
	}
	
	public int[] calcLine(Point a, Point c, Point d) {
		int[] line = new int[3];
		line[0] = 2 * (d.y - c.y);
		line[1] = 2 * (c.x - d.x);
		line[2] = - (d.y - c.y) * (a.x + c.x) - (c.x - d.x) * (a.y + c.y);
		return line;
	}
	
	public void solve() throws Exception {
		Point a, b, c, d;
		while(true) {
			
			a = new Point();
			b = new Point();
			c = new Point();
			d = new Point();
			if (a.isEmpty() && b.isEmpty() && c.isEmpty() && d.isEmpty()) {
				break;
			}
			
			int la = b.y - a.y;
			int lb = a.x - b.x;
			int lc = - la * a.x - lb * a.y;
			if (la * c.x + lb * c.y + lc == 0 && la * d.x + lb * d.y + lc == 0) {
				Point center = new Point(0, 0);
				int dist = Integer.MAX_VALUE;
				if (a.distTo(c) < dist) {
					dist = a.distTo(c);
					center.x = a.x + c.x;
					center.y = a.y + c.y;
				}
				if (a.distTo(d) < dist) {
					dist = a.distTo(d);
					center.x = a.x + d.x;
					center.y = a.y + d.y;
				}
				if (b.distTo(c) < dist) {
					dist = b.distTo(c);
					center.x = b.x + c.x;
					center.y = b.y + c.y;
				}
				if (b.distTo(d) < dist) {
					dist = b.distTo(d);
					center.x = b.x + d.x;
					center.y = b.y + d.y;
				}
				if (a.x == b.x) {
					out.println("0 2 " + (-center.y));
				}
				else {
					out.println("2 0 " + (-center.x));
				}
				continue;
			}
			
			int[] l;
			l = calcLine(a, c, d);
			if (isSolution(l[0], l[1], l[2], a, b, c, d)) {
				out.println(l[0] + " " + l[1] + " " + l[2]);
				continue;
			}
			l = calcLine(b, c, d);
			if (isSolution(l[0], l[1], l[2], a, b, c, d)) {
				out.println(l[0] + " " + l[1] + " " + l[2]);
				continue;
			}
			
			l = calcLine(c, a, b);
			if (isSolution(l[0], l[1], l[2], a, b, c, d)) {
				out.println(l[0] + " " + l[1] + " " + l[2]);
				continue;
			}
			l = calcLine(d, a, b);
			if (isSolution(l[0], l[1], l[2], a, b, c, d)) {
				out.println(l[0] + " " + l[1] + " " + l[2]);
				continue;
			}
			out.println("No solution");
		}
	}
	
	public void run() {
		try {
			solve();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(89);
		} finally {
			out.close();
		}
	}

	public trenches_at(String name) {
		try {
			in = new BufferedReader(new FileReader(name + ".in"));
			st = new StringTokenizer("");
			out = new PrintWriter(new File(name + ".out"));
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(89);
		}
	}
	public static void main(String[] args) {
		(new Thread(new trenches_at("trenches"))).start();
	}
	
	private String nextToken() throws IOException {
		while(!st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}
	
	private double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextToken());
	}
	
	private int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}
}