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 javafx.util.Pair;

import java.io.*;
import java.sql.Array;
import java.util.*;
public class test {
    long max = 0;
    long max1=0;
    boolean visited[];
    PrintStream out = System.out;
    int sign[]={1,0,-1,0,0,1,0,-1};
    ArrayList<Integer> queue = new ArrayList<>();

    public static void main(String args[]) throws IOException {
        test obj = new test();
        obj.start();
    }

    void start() throws IOException {
        Reader sc = new Reader();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // Scanner sc=new Scanner(System.in);
       int x1=sc.nextInt();
        int y1=sc.nextInt();
        int x2=sc.nextInt();
        int y2=sc.nextInt();
        int x3=sc.nextInt();
        int y3=sc.nextInt();
        out.println(3);
        out.println((x1+x2-x3)+" "+(y1+y2-y3));
        out.println((x2+x3-x1)+" "+(y2+y3-y1));
        out.println((x3+x1-x2)+" "+(y3+y1-y2));
     /*   int x[][]=new int[3000][3000];
        switch(1)
        {
            case 1:
            {
                if(x1-x2==0)
                {
                    double d=y1-y2;
                    x[(int) (x3)+1000][(int) (y3+d)+1000]=1;
                    x[(int) (x3)+1000][(int) (y3-d)+1000]=1;
                }
                else {
                    double m = (y1 - y2) / (x1 - x2);
                    double d = Math.sqrt((y1 - y2) * (y1 - y2) + (x1 - x2) * (x1 - x2));
                    int temp= (int) (x3+d*(Math.cos(Math.toDegrees(Math.atan(m)))));
                    int temp2= (int) (y3+d*(Math.sin(Math.toDegrees(Math.atan(m)))));
                    int temp3= (int) (x3-d*(Math.cos(Math.toDegrees(Math.atan(m)))));
                    int temp4= (int) (x3-d*(Math.sin(Math.toDegrees(Math.atan(m)))));
                    x[temp + 1000][temp2 + 1000] = 1;
                    x[temp3+ 1000][temp4+ 1000] = 1;
                  //  out.println((int) (x3 - d *m)+"2");
                   // out.println((int) (x3 + d *m)+"3");
                }
            }
            case 2: {
                if (x1 - x3 == 0) {
                    double d = y1 - y3;
                    x[(int) (x2) + 1000][(int) (y2 + d) + 1000] = 1;
                    x[(int) (x2) + 1000][(int) (y2 - d) + 1000] = 1;
                }
                else {

                    double m = (y1 - y3) / (x1 - x3);
                    double d = Math.sqrt((y1 - y3) * (y1 - y3) + (x1 - x3) * (x1 - x3));
                    int temp= (int) (x2+d*(Math.cos(Math.toDegrees(Math.atan(m)))));
                    int temp2= (int) (y2+d*Math.cos((Math.toDegrees(Math.atan(m)))));
                    int temp3= (int) (x2-d*(Math.cos(Math.toDegrees(Math.atan(m)))));
                    int temp4= (int) (x2-d*(Math.sin(Math.toDegrees(Math.atan(m)))));
                    x[temp + 1000][temp2 + 1000] = 1;
                    x[temp3+ 1000][temp4+ 1000] = 1;
                }
            }
            case 3:
            {
                if(x3-x2==0)
                {
                    double d=y3-y2;
                    x[(int) (x1)+1000][(int) (y1+d)+1000]=1;
                    x[(int) (x1)+1000][(int) (y1-d)+1000]=1;
                }
                else {
                    double m = (y3 - y2) / (x3 - x2);
                    double d = Math.sqrt((y3 - y2) * (y3 - y2) + (x3 - x2) * (x3 - x2));
                    int temp= (int) (x1+d*(Math.cos(Math.toDegrees(Math.atan(m)))));
                    int temp2= (int) (y1+d*(Math.sin(Math.toDegrees(Math.atan(m)))));
                    int temp3= (int) (x1-d*(Math.cos(Math.toDegrees(Math.atan(m)))));
                    int temp4= (int) (x1-d*(Math.sin(Math.toDegrees(Math.atan(m)))));
                    x[temp + 1000][temp2 + 1000] = 1;
                    x[temp3+ 1000][temp4+ 1000] = 1;  }
            }
        }
        int count=0;
        for(int i=0;i<3000;i++) {
            for (int j = 0; j < 3000; j++)
                if(x[i][j]==1)
                    count+=1;
        }
        out.println(count);
        for(int i=0;i<3000;i++) {
            for (int j = 0; j < 3000; j++)
                  if(x[i][j]==1)
                      out.println((i-1000)+" "+(j-1000));
        }*/
    }

    //<---------------------------------------------------------------------------------------------------------------->//


    //printing 2-d array
    private void println(int[][] a,int n,int m) {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
                System.out.print(a[i][j]);
            System.out.println();
        }

    }


    //modified dfs for chessboard, matrix
    void dfs(char a[][],int i,int j,char t,int n,int m)
    {
        //visited[i]=true;
        a[i][j]=t;
        if(t=='B')
            t='W';
        else
            t='B';
        for (int c= 0; c < 4; c++) {

            int temp=i+sign[2*c];
            int temp2=j+sign[2*c+1];
            if(temp>=0&&temp<n&&temp2>=0&&temp2<m) {
                if(a[temp][temp2]=='.'&&a[temp][temp2]!='-')
                    dfs(a,temp,temp2,t,n,m);
            }
        }
    }


     //constructing segment tree
    private void constructseg(long[] seg, long[] input, int p, int q, int pos) {
        if(p==q)
        {
            seg[pos]=input[p];
            return;
        }
        int mid=(q+p)/2;
        constructseg(seg,input,p,mid,2*pos+1);
        constructseg(seg,input,mid+1,q,2*pos+2);
        seg[pos]=seg[2*pos+1]+seg[2*pos+2];
    }


    //traversing through a arrayList graph
    void dfs(ArrayList<Integer> node[],int i,int count,int cat[],int k)
    {
        visited[i]=true;
        if(cat[i]==1) {
            count++;
        }
        else
            count=0;
        if(count>k) {
            return;
        }
        if(node[i].size()==1&&i!=0) {
            max += 1;
        }
        for (int j = 0; j < node[i].size(); j++) {
            if(!visited[node[i].get(j)])
                dfs(node, node[i].get(j), count, cat, k);
        }

    }


    //printing arraylist array
    void println(ArrayList<Integer> a[])
    {
          for (ArrayList<Integer> b:a
               ) {
              System.out.println(b.toString());
          }
    }

    //sorting 2 array based on a, Complexity is O(n^2)
    void sort(int a[],int b[],int n)
    {
        for(int i=1;i<n;i++)
        {
            int index=i;
            for(int j=i-1;j>=0;j--)
            {
              //  println(a);
                if(a[index]<a[j])
                {
                    int temp=a[index];
                    int temp2=b[index];
                    a[index]=a[j];
                    b[index]=b[j];
                    a[j]=temp;
                    b[j]=temp2;
                    index=j;

                }
                else
                    break;
            }
        }

    }
     // to create and initialize Integer array
    private int[] intArray(int a, Scanner sc) {
        int temp[]=new int[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextInt();
        }
        return temp;
    }

    private int[] intArray(int a, Reader sc) throws IOException {
        int temp[]=new int[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextInt();
        }
        return temp;
    }// / to create and initialize Long Array
    private long[] longArray(int a, Scanner sc) {
        long temp[]=new long[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextLong();
        }
        return temp;
    }

    // displaying Map contents key--value
    public static void printMap(Map mp) {
        Iterator it = mp.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pair = (Map.Entry)it.next();
            System.out.println(pair.getKey() + " = " + pair.getValue());
            it.remove(); // avoids a ConcurrentModificationException
        }
    }


    // Return arrayList of minimum factor of number
    // 24= 2*2*2*3;
    private ArrayList<Integer> minFactor(int a) {
        ArrayList<Integer> obj=new ArrayList<>();
        for(int i=2;i<=a;i++)
        {
            while(a!=0&&a%i==0)
            {
                obj.add(i);
                a/=i;
            }
        }
        return obj;
    }


    // check whether the number is prime or not
    public static boolean isPrimeNumber(int i) {
        int factors = 0;
        int j = 1;

        while(j <= i)
        {
            if(i % j == 0)
            {
                factors++;
            }
            j++;
        }
        return (factors == 2);
    }

    // creating and initializing arrayList
    private void initArrayList(ArrayList<Integer>[] tempa) {
        for(int i=0;i<tempa.length;i++)
            tempa[i]=new ArrayList<>();
    }

    // return factorial contents as ArrayList
    private ArrayList<Integer> factdigit(int i)
    {
        ArrayList<Integer> temp=new ArrayList<>();
        for(int j=i;j>1;j--)
        {
            temp.add(j);
        }
        return temp;
    }

    //printing Integer array
    private  void println(int a[])
    {
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }
    int factorial(int n){
        if (n == 0)
            return 1;
        else
            return((n %1000000007)* (factorial(n-1)%1000000007));
    }
}





class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[300]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null)
            return;
        din.close();
    }
}