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.util.*;
import java.io.*;
import java.math.*;
import java.math.BigInteger;
import java.text.DecimalFormat;
  public class Tester {
	//static long sum=0,sum1=Long.MAX_VALUE;
	//DecimalFormat df = new DecimalFormat("#.#####");
	public static final long MOD = (long) (1e9 + 7);
		static long h[];
			// Driver program to test above function
		    public static void main(String args[])
		    {
		    	Scanner sc=new Scanner(System.in);
		    	InputReader in = new InputReader(System.in);
		  	  	OutputStream outputStream = System.out;
		  	  	PrintWriter out = new PrintWriter(outputStream);
		  	  double x[]=new double[3];
		  	  double y[]=new double[3];
		  	  	HashMap<String,Integer> h=new HashMap();
			  	  ArrayList<String> arr=new ArrayList();
		  	  	for(int i=0;i<3;i++)
		  	  	{
		  	  		x[i]=sc.nextDouble();
		  	  		y[i]=sc.nextDouble();
		  	  	}
		  	  	double mid1=0,mid2=0;
		  	  	mid1=(x[0]+x[1])/2;
		  	  	mid2=(y[0]+y[1])/2;
		  	  	double p=2*mid1-x[2];
		  	  	double q=2*mid2-y[2];
		  	  	int count=0;
		  	  	if(Math.ceil(p)==p)
		  	  		p=(int)p;
		  		if(Math.ceil(q)==q)
		  	  		q=(int)q;

		  		if(Math.ceil(p)==p&&Math.ceil(q)==q)
		  		{
		  			int g=(int)p;
		  			int w=(int)q;
		  			if(!h.containsKey(g+" "+w))
			  	  	{
			  	  		count++;
			  	  		h.put(g+" "+w,1);
			  	  		arr.add(g+" "+w);
			  	  	}
		  		}
		  		else if(Math.ceil(p)==p)
		  		{
		  			int g=(int)p;
		  			//int w=(int)q;
		  			if(!h.containsKey(g+" "+q))
			  	  	{
			  	  		count++;
			  	  		h.put(g+" "+q,1);
			  	  		arr.add(g+" "+q);
			  	  	}
		  		}
		  		else if(Math.ceil(q)==q)
		  		{
		  			//int g=(int)p;
		  			int w=(int)q;
		  			if(!h.containsKey(p+" "+w))
			  	  	{
			  	  		count++;
			  	  		h.put(p+" "+w,1);
			  	  		arr.add(p+" "+w);
			  	  	}
		  		}
		  		else
		  		{
		  			if(!h.containsKey(p+" "+q))
			  	  	{
			  	  		count++;
			  	  		h.put(p+" "+q,1);
			  	  		arr.add(p+" "+q);
			  	  	}
		  		}
		  	   mid1=0;mid2=0;
		  	  	mid1=(x[1]+x[2])/2;
		  	  	mid2=(y[2]+y[1])/2;
		  	  	p=2*mid1-x[0];
		  	  	q=2*mid2-y[0];

		  		if(Math.ceil(p)==p&&Math.ceil(q)==q)
		  		{
		  			int g=(int)p;
		  			int w=(int)q;
		  			if(!h.containsKey(g+" "+w))
			  	  	{
			  	  		count++;
			  	  		h.put(g+" "+w,1);
			  	  		arr.add(g+" "+w);
			  	  	}
		  		}
		  		else if(Math.ceil(p)==p)
		  		{
		  			int g=(int)p;
		  			//int w=(int)q;
		  			if(!h.containsKey(g+" "+q))
			  	  	{
			  	  		count++;
			  	  		h.put(g+" "+q,1);
			  	  		arr.add(g+" "+q);
			  	  	}
		  		}
		  		else if(Math.ceil(q)==q)
		  		{
		  			//int g=(int)p;
		  			int w=(int)q;
		  			if(!h.containsKey(p+" "+w))
			  	  	{
			  	  		count++;
			  	  		h.put(p+" "+w,1);
			  	  		arr.add(p+" "+w);
			  	  	}
		  		}
		  		else
		  		{
		  			if(!h.containsKey(p+" "+q))
			  	  	{
			  	  		count++;
			  	  		h.put(p+" "+q,1);
			  	  		arr.add(p+" "+q);
			  	  	}
		  		}
		 	   mid1=0;mid2=0;
		  	  	mid1=(x[0]+x[2])/2;
		  	  	mid2=(y[2]+y[0])/2;
		  	  	p=2*mid1-x[1];
		  	  	q=2*mid2-y[1];
		  	  	
		  		if(Math.ceil(p)==p&&Math.ceil(q)==q)
		  		{
		  			int g=(int)p;
		  			int w=(int)q;
		  			if(!h.containsKey(g+" "+w))
			  	  	{
			  	  		count++;
			  	  		h.put(g+" "+w,1);
			  	  		arr.add(g+" "+w);
			  	  	}
		  		}
		  		else if(Math.ceil(p)==p)
		  		{
		  			int g=(int)p;
		  			//int w=(int)q;
		  			if(!h.containsKey(g+" "+q))
			  	  	{
			  	  		count++;
			  	  		h.put(g+" "+q,1);
			  	  		arr.add(g+" "+q);
			  	  	}
		  		}
		  		else if(Math.ceil(q)==q)
		  		{
		  			//int g=(int)p;
		  			int w=(int)q;
		  			if(!h.containsKey(p+" "+w))
			  	  	{
			  	  		count++;
			  	  		h.put(p+" "+w,1);
			  	  		arr.add(p+" "+w);
			  	  	}
		  		}
		  		else
		  		{
		  			if(!h.containsKey(p+" "+q))
			  	  	{
			  	  		count++;
			  	  		h.put(p+" "+q,1);
			  	  		arr.add(p+" "+q);
			  	  	}
		  		}
		  	  	out.println(count);
		  	  	for(int i=0;i<arr.size();i++)
		  	  	{
		  	  		out.println(arr.get(i));
		  	  	}
		  	  	//out.println(h);
		  	  	
		  	  	out.close();	
		  	  }
		    static void dfs(int root,ArrayList arr[],long height)
		    {
		    	Iterator<Integer> iterator = arr[root].iterator();
		    	h[root]=height;
		    	while(iterator.hasNext())
		    	{
		    		dfs(iterator.next(),arr,height+1);
		    	}
		    }
		    static int ceilSearch(long arr[], int low, int high, long x)
		    {
		      int mid;    
		     
		      /* If x is smaller than or equal to the first element,
		        then return the first element */
		      if(x <= arr[low])
		        return low; 
		     
		      /* If x is greater than the last element, then return -1 */
		      if(x > arr[high])
		        return -1;  
		     
		      /* get the index of middle element of arr[low..high]*/
		      mid = (low + high)/2;  /* low + (high - low)/2 */
		     
		      /* If x is same as middle element, then return mid */
		      if(arr[mid] == x)
		        return mid;
		         
		      /* If x is greater than arr[mid], then either arr[mid + 1]
		        is ceiling of x or ceiling lies in arr[mid+1...high] */ 
		      else if(arr[mid] < x)
		      {
		        if(mid + 1 <= high && x <= arr[mid+1])
		          return mid + 1;
		        else
		          return ceilSearch(arr, mid+1, high, x);
		      }
		     
		      /* If x is smaller than arr[mid], then either arr[mid] 
		         is ceiling of x or ceiling lies in arr[mid-1...high] */   
		      else
		      {
		        if(mid - 1 >= low && x > arr[mid-1])
		          return mid;
		        else    
		          return ceilSearch(arr, low, mid - 1, x);
		      }
		    }
		    static int floorSearch(long arr[], int low, int high, long x)
		    {
		      int mid;    
		     
		      /* If x is smaller than or equal to the first element,
		        then return the first element */
		      if(x >= arr[high])
		        return high; 
		     
		      /* If x is greater than the last element, then return -1 */
		      if(x < arr[low])
		        return -1;  
		     
		      /* get the index of middle element of arr[low..high]*/
		      mid = (low + high)/2;  /* low + (high - low)/2 */
		     
		      /* If x is same as middle element, then return mid */
		      if(arr[mid] == x)
		        return mid;
		         
		      /* If x is greater than arr[mid], then either arr[mid + 1]
		        is ceiling of x or ceiling lies in arr[mid+1...high] */ 
		      else if(arr[mid] < x)
		      {
		        if(mid + 1 <= high && x < arr[mid+1])
		          return mid;
		        else
		          return floorSearch(arr, mid+1, high, x);
		      }
		     
		      /* If x is smaller than arr[mid], then either arr[mid] 
		         is ceiling of x or ceiling lies in arr[mid-1...high] */   
		      else
		      {
		        if(mid - 1 >= low && x >= arr[mid-1])
		          return mid-1;
		        else    
		          return floorSearch(arr, low, mid - 1, x);
		      }
		    }
		    static long binaryExponentiation(long x,long n)
		    {
		        long result=1;
		        while(n>0)
		        {
		            result=(result%MOD*x%MOD)%MOD;
		            n--;
		        }
		        return result;
		    }
		    static long nCr(int n, int r){
				long rfact=1, nfact=1, nrfact=1,temp1 = n-r ,temp2 = r;
				if(r>n-r)
				{
					temp1 =r;
					temp2 =n-r;
				}
				for(int i=1;i<=n;i++)
				{
					if(i<=temp2)
					{
						rfact = (rfact%MOD* i%MOD)%MOD;
						nrfact = (nrfact%MOD* i%MOD)%MOD;
					}
					else if(i<=temp1)
					{
						nrfact = (nrfact%MOD* i%MOD)%MOD;
					}
					nfact = (nfact%MOD* i%MOD)%MOD;
				}
				return nfact/(rfact*nrfact);
			}
		    public static long find_ncr(long n, long r) {
		    	long result=1;
		    	 //  System.out.println(factorial(29));
		    	   result = factorial(n)/(factorial(r)*factorial(n-r));
		    	   return result;
		    	}
		   public static long factorial(long n) {
		    	   long c;
		    	   long result = 1;
		    	 
		    	   for (c = 1; c <= n; c++)
		    	      result = result*c;
		    	 
		    	   return result;
		    	}
		    public static long power(long base, long exp) {
		        long res=1;
		        while(exp>0) {
		           if(exp%2==1) res=(res*base)%MOD;
		           base=(base*base)%MOD;
		           exp/=2;
		        }
		        return res%MOD;
		    }
	public static void computeLPSArray(String pat, int M, int lps[])
    {
        // length of the previous longest prefix suffix
        int len = 0;
        int i = 1;
        lps[0] = 0;  // lps[0] is always 0
 
        // the loop calculates lps[i] for i = 1 to M-1
        while (i < M)
        {
            if (pat.charAt(i) == pat.charAt(len))
            {
                len++;
                lps[i] = len;
                i++;
            }
            else  // (pat[i] != pat[len])
            {
                // This is tricky. Consider the example.
                // AAACAAAA and i = 7. The idea is similar 
                // to search step.
                if (len != 0)
                {
                    len = lps[len-1];
 
                    // Also, note that we do not increment
                    // i here
                }
                else  // if (len == 0)
                {
                    lps[i] = len;
                    i++;
                }
            }
        }
    }
	 	public static void KMPSearch(String pat, String txt)
	    {
	 		System.out.println("sdfsdf");
	        int M = pat.length();
	        int N = txt.length();
	 
	        // create lps[] that will hold the longest
	        // prefix suffix values for pattern
	        int lps[] = new int[M];
	        int j = 0;  // index for pat[]
	 
	        // Preprocess the pattern (calculate lps[]
	        // array)
	        computeLPSArray(pat,M,lps);
	 
	        int i = 0;  // index for txt[]
	        while (i < N)
	        {
	            if (pat.charAt(j) == txt.charAt(i))
	            {
	                j++;
	                i++;
	            }
	            if (j == M)
	            {
	                System.out.println("Found pattern "+
	                              "at index " + (i-j));
	                j = lps[j-1];
	            }
	 
	            // mismatch after j matches
	            else if (i < N && pat.charAt(j) != txt.charAt(i))
	            {
	                // Do not match lps[0..lps[j-1]] characters,
	                // they will match anyway
	                if (j != 0)
	                    j = lps[j-1];
	                else
	                    i = i+1;
	            }
	        }
	    }
	public static long power(long i)
	{
		long c=1;
		while(i>1)
		{
			c=((c%MOD)*(2%MOD))%MOD;
			i--;
		}
		return c;
	}
	public static long gcd(long p, long q) {
        if (q == 0) {
                return p;
        }
        return gcd(q, p % q);
}
	static int mid=-1;
	static int find(int arr[],int k,int f,int l)
	{
		if(f>l)
			return mid;
		mid=(f+l)/2;
		if(arr[mid]==k)
			return mid;
		if(arr[mid]<k)
		{
			f=mid;
			return find(arr,k,f,l);
		}
		else
		{
			l=mid;
			return find(arr,k,f,l);
		}
	}
	static void merge(long arr[], int l, int m, int r)
	{
	    int i, j, k;
	    int n1 = m - l + 1;
	    int n2 =  r - m;
	 
	    /* create temp arrays */
	    long L[]=new long[n1];
	    long R[]=new long[n2];
	 
	    /* Copy data to temp arrays L[] and R[] */
	    for (i = 0; i < n1; i++)
	        L[i] = arr[l + i];
	    for (j = 0; j < n2; j++)
	        R[j] = arr[m + 1+ j];
	 
	    /* Merge the temp arrays back into arr[l..r]*/
	    i = 0; // Initial index of first subarray
	    j = 0; // Initial index of second subarray
	    k = l; // Initial index of merged subarray
	    while (i < n1 && j < n2)
	    {
	        if (L[i] <= R[j])
	        {
	            arr[k] = L[i];
	            i++;
	        }
	        else
	        {
	            arr[k] = R[j];
	            j++;
	        }
	        k++;
	    }
	 
	    /* Copy the remaining elements of L[], if there
	       are any */
	    while (i < n1)
	    {
	        arr[k] = L[i];
	        i++;
	        k++;
	    }
	 
	    /* Copy the remaining elements of R[], if there
	       are any */
	    while (j < n2)
	    {
	        arr[k] = R[j];
	        j++;
	        k++;
	    }
	}
	 
	/* l is for left index and r is right index of the
	   sub-array of arr to be sorted */
	static void mergeSort(long arr[], int l, int r)
	{
	    if (l < r)
	    {
	        // Same as (l+r)/2, but avoids overflow for
	        // large l and h
	        int m = l+(r-l)/2;
	 
	        // Sort first and second halves
	        mergeSort(arr, l, m);
	        mergeSort(arr, m+1, r);
	 
	        merge(arr, l, m, r);
	    }
	}
	private static int[] nextIntArray(InputReader in,int n)	
	{
		int[] a=new int[n];
		for(int i=0;i<n;i++)
			a[i]=in.nextInt();
		return a;
	}
	public static double dis(double x1,double x2,double y1)
	{
		return Math.sqrt(((x1-x2)*(x1-x2))+(y1*y1));
	}
	private static String[] nextStringArray(InputReader in,int n)	
	{
		String[] a=new String[n];
		for(int i=0;i<n;i++)
			a[i]=in.next();
		return a;
	}
	private static void show(int[] a)
	{
		for(int i=0;i<a.length;i++)
			System.out.print(a[i]+" ");
		System.out.println();
	}
	private static void show2DArray(char[][] a)
	{
		for(int i=0;i<a.length;i++)
		{
			for(int j=0;j<a[0].length;j++)
				System.out.print(a[i][j]);
			System.out.println();
		}
	}
 static long fact(long x)
 {
	 long i=x,mul=1;
	 while(i>0)
	 {
		 mul=(mul%1000000007)*(i%1000000007)%1000000007;
		 i--;
	 }
	 return mul;
 }
 static class LengthComparator implements Comparator<String> {
	    public int compare(String arg0, String arg1) {
		// Use Integer.compare to compare the two Strings' lengths.
		return (arg0+arg1).compareTo(arg1+arg0);
	    }
	}
// static long output(ArrayList<Integer> h[],int j,boolean[] v)
// {
//	 int k;
//	 v[j]=true;
//	 sum++;
//	 for(k=0;k<h[j].size();k++)
//	 {
//		 if(v[h[j].get(k)]==false)
//		 {
//			 output(h,h[j].get(k),v);
//		 }
//	 }
//	 return sum;
// }
 static long func(boolean v[],int j,ArrayList<Integer> h[],long ban[])
 {
	 	v[j]=true;
	 	 int k;
	 	long sum=0;
	    sum=sum+ban[j];
	 	//System.out.println(h[j].size());
	 	for(k=0;k<h[j].size();k++)
	 	{
	 		if(v[h[j].get(k)]==false)
	 		{
	 			v[h[j].get(k)]=true;
	 			sum+=func(v,h[j].get(k),h,ban);
	 		}
	 	}
	 	return sum;
 }
/*static class Graph {
    	
    	private static Deque<Integer> stack = new ArrayDeque<Integer>();
 		private int least,count,v;
 		
		Set<Integer>[] cities;
    	private int[] risk;
    	
    	Graph(int n,String[] risk){
    		
    		cities = new HashSet[n];
    		this.risk = new int[n];
    		for(int i =0;i<n;i++){
    			cities[i] = new HashSet<>();
    		}
    		for(int i =0;i<n;i++){
    			this.risk[i] = Integer.parseInt(risk[i]);
    		}
    		visited = new boolean[n];
    	}
    	
    	
    	public void add(int x,int y){
    		cities[x].add(y);
    		cities[y].add(x);
    	}
}*/
	static int root(int arr[],int i)
	{
		while(arr[i]!=i)
		{
			i=arr[i];
		}
		return i;
	}
	static boolean find(int arr[],int a,int b)
	{
		if(root(arr,a)==root(arr,b))
		{
			return true;
		}
		else
			return false;
	}
	static void weighted_union(int arr[],int size[],int a,int b)
	{
		int root_a=root(arr,a);
		int root_b=root(arr,b);
		if(root_a!=root_b)
		{
			if(size[root_a]<size[root_b])
			{
				arr[root_a]=arr[root_b];
				size[root_b]+=size[root_a];
			}
			else
			{
				arr[root_b]=arr[root_a];
				size[root_a]+=size[root_b];
			}
		//	count--;
		}
	}
	static class Pair implements Comparable<Pair>
	{
		private long first;
		private long index;
		//private long second;;
 
		public Pair(long i, long j) 
		{ 
			this.first = i;
			this.index = j;
		}
		public Pair() {
			// TODO Auto-generated constructor stub
		}
		public long getFirst() { return first; }
		//public long getSecond() { return second; }
		public long getIndex() { return index ;}
		public void setFirst(long k) { this.first=k ; }
		public void setIndex(long k) { this.index=k ;}
		//public void setSecond(long k) { this.second=k ;}
		@Override
		public int compareTo(Pair o) 
		{
			return Long.compare(this.first, o.first);
		}
		
	}
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
 
		public InputReader(InputStream inputstream) {
			reader = new BufferedReader(new InputStreamReader(inputstream));
			tokenizer = null;
		}
 
		public String nextLine(){
			String fullLine=null;
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					fullLine=reader.readLine();
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
				return fullLine;
			}
			return fullLine;
		}
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}