Problem: Arpa is taking a geometry exam. Here is the last problem of the exam.

You are given three points a, b, c.

Find a point and an angle such that if we rotate the page around the point by the angle, the new position of a is the same as the old position of b, and the new position of b is the same as the old position of c.

Arpa is doubting if the problem has a solution or not (i.e. if there exists a point and an angle satisfying the condition). Help Arpa determine if the question has a solution or not.

Input

The only line contains six integers ax, ay, bx, by, cx, cy (|ax|, |ay|, |bx|, |by|, |cx|, |cy| ≤ 109). It's guaranteed that the points are distinct.

Output

Print "Yes" if the problem has a solution, "No" otherwise.

You can print each letter in any case (upper or lower).

Examples

Input

0 1 1 1 1 0


Output

Yes


Input

1 1 0 0 1000 1000


Output

No

Note

In the first sample test, rotate the page around (0.5, 0.5) by <image>.

In the second sample test, you can't find any solution.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.PriorityQueue;

public class Solution
{

    /*--------------solution--------------*/ //PROBABLY WRONG LOL
    public static void main(String[] args)
    {
        Reader in = new Reader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        Point pnts[] = new Point[3];
        boolean ans = false;

        for(int i = 0;i < 3;i++)
        {
            long x = in.nextLong() ,
                    y = in.nextInt();
            pnts[i] = new Point(x , y);
        }

        ans = !isLinear(pnts) && (squaredDis(pnts[0] , pnts[1]) ==
                                 squaredDis(pnts[1] , pnts[2]));

        out.println(ans ? "YES" : "NO");
        out.close();
    }

    public static long squaredDis(Point a , Point b)
    {
        return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
    }

    public static boolean isLinear(Point[] pnts)
    {
        return (pnts[0].y - pnts[1].y) * (pnts[0].x - pnts[2].x) ==
               (pnts[0].y - pnts[2].y) * (pnts[0].x - pnts[1].x);
    }

    static class Point
    {
        long x;
        long y;

        public Point(long x , long y)
        {
            this.x = x;
            this.y = y;
        }
    }
    /*--------------solution--------------*/

    ///////////////////////////////////////////////////////////////////////////////////

    /*------------fast io------------*/
    static class Reader
    {

        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public Reader(InputStream in)
        {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

        public String next()
        {
            while(tokenizer == null || !tokenizer.hasMoreTokens())
            {
                try
                {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt()
        {
            return Integer.parseInt(next());
        }

        public long nextLong()
        {
            return Long.parseLong(next());
        }

    }
  /*------------fast io------------*/

}