Problem: Long time ago Alex created an interesting problem about parallelogram. The input data for this problem contained four integer points on the Cartesian plane, that defined the set of vertices of some non-degenerate (positive area) parallelogram. Points not necessary were given in the order of clockwise or counterclockwise traversal.

Alex had very nice test for this problem, but is somehow happened that the last line of the input was lost and now he has only three out of four points of the original parallelogram. He remembers that test was so good that he asks you to restore it given only these three points.

Input

The input consists of three lines, each containing a pair of integer coordinates xi and yi ( - 1000 ≤ xi, yi ≤ 1000). It's guaranteed that these three points do not lie on the same line and no two of them coincide.

Output

First print integer k — the number of ways to add one new integer point such that the obtained set defines some parallelogram of positive area. There is no requirement for the points to be arranged in any special order (like traversal), they just define the set of vertices.

Then print k lines, each containing a pair of integer — possible coordinates of the fourth point.

Example

Input

0 0
1 0
0 1


Output

3
1 -1
-1 1
1 1

Note

If you need clarification of what parallelogram is, please check Wikipedia page:

https://en.wikipedia.org/wiki/Parallelogram

Solution (in JAVA):

Solution:
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
//import Queue.node;
public class TestClass {
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	static int max = 0,temp = 0;
public static class BinarySearchTree {
	Node head;
	public void add(long a,Node q){
		if(head==null){
			Node p = new Node(a);
			head = p;
			p.parent = null;
			max = 1;
			temp = 1;
		}
		else{
			if(q.value>a){
				if(q.previous!=null){
					temp++;
					add(a,q.previous);
				}
				else{
					Node p = new Node(a);
					q.previous = p;
					p.parent = q;
					if(max<temp+1)
						max = temp+1;
					temp = 1;
				}
			}
			else{
				if(q.next!=null){
					temp++;
					add(a,q.next);
				}
				else{
					Node p = new Node(a);
					q.next = p;
					p.parent = q;
					if(max<temp+1)
						max = temp+1;
					temp = 1;
				}
			}
		}
	}
	public void se(TreeSet a,int x,Node q){
		if(q.value==x){
			a.add(q.value);
			return ;
		}
		else if(q.value>x){
			a.add(q.value);
			se(a,x,q.previous);
		}
		else{
			a.add(q.value);
			se(a,x,q.next);
		}
	}
	public long parent(Node p){
		Node q = p;
		if(q.next!=null){
			q = q.next;
			while(q.previous!=null)
				q = q.previous;
			return q.value;
		}
		while(true){
			if(q.parent.previous==q)
				return q.parent.value;
			q = q.parent;
		}
	}
	public long getJustMax(long a,Node q){
		long x=0;
		if(q==null)
			return 0;
		if(a>q.value)
			x = getJustMax(a,q.next);
		else if(a==q.value)
			return parent(q);
		else
			x = getJustMax(a,q.previous);
		return x;
	}
}

public static class Node {
	Node next;
	Node previous;
	Node parent;
	long value;
	public Node(long a){
		value = a;
		next = null;
		previous = null;
	}
}

	public static class Queue{
		private class node{
			int val;
			node next;
			node(int a){
				val = a;
				next = null;
			}
		}
		node head,tail;
		Queue(){
			head = null;
			tail = null;
		}
		public void EnQueue(int a){
			if(head==null){
				node p = new node(a);
				head = p;
				tail = p;
			}
			else{
				node p = new node(a);
				tail.next = p;
				tail = p;
			}
		}
		public int DeQueue(){
			int a = head.val;
			head = head.next;
			return a;
		}
		public boolean isEmpty(){
			return head==null;
		}
	}
    public static long pow(long x,long y,long m){
    	if(y==0)
    		return 1;
    	long k = pow(x,y/2,m);
    	if(y%2==0)
    		return (k*k)%m;
    	else
    		return (((k*k)%m)*x)%m;
    }
    static long Inversex = 0,Inversey = 0;
    public static void InverseModulo(long a,long m){
    	if(m==0){
    		Inversex = 1;
    		Inversey = 0;
    	}
    	else{
    		InverseModulo(m,a%m);
    		long temp = Inversex;
    		Inversex = Inversey;
    		Inversey = temp+ - (a/m)*Inversey;
    	}
    }
    static long mod1 = 1000000007;
    static long mod2 = 1000000009;
	public static long gcd(long a,long b){
		if(a%b==0)
			return b;
		return gcd(b,a%b);
	}
	public static boolean isPrime(long a){
		if(a==1)
			return false;
		else if(a==2||a==3)
			return true;
		for(long i=2;i<=Math.sqrt(a);i++)
			if(a%i==0)
				return false;
		return true;
	}
	public static double distance(int a,int b,int x,int y){
		return Math.sqrt(((long)(a-x)*(long)(a-x))+((long)(b-y)*(long)(b-y)));
	}
	public static class Pair implements Comparable<Pair> {
		long u;
		long v;
		BigInteger bi;
		public Pair(long u, long v) {
			this.u = u;
			this.v = v;
		}
		public int hashCode() {
			int hu = (int) (u ^ (u >>> 32));
			int hv = (int) (v ^ (v >>> 32));
			return 31 * hu + hv;
		}
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return u == other.u && v == other.v;
		}
		public int compareTo(Pair other) {
			return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
		}
		public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}
	}
	public static int seive(int a[],boolean b[],ArrayList c){
		int count = 0;
		for(int i=2;i*i<a.length;i++){
			if(!b[i]){
				for(int j=i*i;j<a.length;j=j+i)
					b[j] = true;
				c.add(i);
				a[count++] = i;
			}
		}
		return count;
	}
	public static void MatrixMultiplication(int a[][],int b[][],int c[][]){
		for(int i=0;i<a.length;i++){
			for(int j=0;j<b[0].length;j++){
				c[i][j] = 0;
				for(int k=0;k<b.length;k++)
					c[i][j]=(int)((c[i][j]+((a[i][k]*(long)b[k][j])%mod1))%mod1);
			}
		}
	}
	public static void Equal(int arr[][],int temp[][]){
		for(int i=0;i<arr.length;i++){
			for(int j=0;j<arr.length;j++)
				temp[i][j] = arr[i][j];
		}
	}
	private static void soln(){
		/*BinarySearchTree h = new BinarySearchTree();
		int n = nI();
		Node head = null;
		while(n-->0){
			h.add(nI(), head);
			head = h.head;
		}
		int x = nI();
		TreeSet a = new TreeSet();
		h.se(a, x, head);
		int y = nI();
		TreeSet b = new TreeSet();
		h.se(b, y, head);
		while(true){
			if(a.last()==b.last()){
				if((long)a.last()>Math.max(x, y))
					pw.println(a.last());
				else
					pw.println(Math.max(x, y));
				break;
			}
			else if((long)a.last()>(long)b.last())
				a.pollLast();
			else
				b.pollLast();
		}*/
		Pair p[] = new Pair[3];
		PriorityQueue<Pair> h = new PriorityQueue<Pair>();
		for(int i=0;i<3;i++){
			Pair u = new Pair(nI(),nI());
			h.add(u);
		}
		for(int i=0;i<3;i++){
			Pair u = h.poll();
			p[i] = new Pair(u.u,u.v);
		}
		if(p[1].u*2==(p[0].u+p[1].u)&&p[1].v*2==(p[0].v+p[2].v))
			pw.println("0");
		else{
			pw.println("3");
			for(int i=0;i<3;i++)
				pw.println(((p[i].u-p[(i+1)%3].u)+p[(i+2)%3].u)+" "+((p[i].v-p[(i+1)%3].v)+p[(i+2)%3].v));
		}
	}
	public static void main(String[] args) {
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		soln();
		pw.close();
	}
	// To Get Input
	// Some Buffer Methods
	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}
	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
	private static int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}
	private static int nI() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	private static long nL() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}
	private static String nLi() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}
	private static int[] nIA(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = nI();
		return arr;
	}
	private static long[] nLA(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++)
			arr[i] = nL();
		return arr;
	}
	private static void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++)
			pw.print(arr[i] + " ");
		pw.println();
		return;
	}
	private static void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++)
			pw.print(arr[i] + " ");
		pw.println();
		return;
	}
	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}
	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}