Problem: There is a strange peculiarity: if you connect the cities of Rostov, Taganrog and Shakhty, peculiarly, you get a triangle

«Unbelievable But True»

Students from many different parts of Russia and abroad come to Summer Informatics School. You marked the hometowns of the SIS participants on a map.

Now you decided to prepare an interesting infographic based on this map. The first thing you chose to do is to find three cities on this map, such that they form a triangle with area S.

Input

The first line of input contains two integers n and S (3 ≤ n ≤ 2000, 1 ≤ S ≤ 2 ⋅ 10^{18}) — the number of cities on the map and the area of the triangle to be found.

The next n lines contain descriptions of the cities, one per line. Each city is described by its integer coordinates x_i, y_i (-10^9 ≤ x_i, y_i ≤ 10^9). 

It is guaranteed that all cities are located at distinct points. It is also guaranteed that no three cities lie on the same line.

Output

If the solution doesn't exist — print «No».

Otherwise, print «Yes», followed by three pairs of coordinates (x, y) — the locations of the three cities, which form the triangle of area S.

Examples

Input

3 7
0 0
3 0
0 4


Output

No


Input

4 3
0 0
2 0
1 2
1 3


Output

Yes
0 0
1 3
2 0

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Comparator;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        long cross(Point a, Point b) {
            return (long) a.x * b.y - (long) a.y * b.x;
        }

        long cross(Segment s1, Segment s2) {
            return (long) (s1.b.x - s1.a.x) * (s2.b.y - s2.a.y) - (long) (s1.b.y - s1.a.y) * (s2.b.x - s2.a.x);
        }

        long triangle_area(Point a, Point b, Point c) {
            return Math.abs(cross(a, b) + cross(b, c) + cross(c, a));
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.readInt();
            long S = in.readLong();
            Point[] points = new Point[n];
            for (int i = 0; i < n; ++i) {
                int x = in.readInt();
                int y = in.readInt();
                points[i] = new Point(x, y);
            }
            Arrays.sort(points, new Comparator<Point>() {

                public int compare(Point o1, Point o2) {
                    if (o1.y == o2.y) return o2.x - o1.x;
                    else return o2.y - o1.y;
                }
            });
            for (int i = 0; i < n; ++i) {
                points[i].index = i;
            }
            Segment[] segments = new Segment[(n * (n - 1)) / 2];
            int k = 0;
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < i; ++j) {
                    segments[k++] = new Segment(points[j], points[i]);
                }
            }
            Arrays.sort(segments, new Comparator<Segment>() {

                public int compare(Segment o1, Segment o2) {
                    return -1 * Long.signum(cross(o1, o2));
                }
            });
            //if (n > 1500) return;
            long target_area = S * 2;
            Random random = new Random();
            for (Segment s : segments) {
                //System.err.println(s.a.index + " " + s.b.index);
                int first = s.a.index;
                int second = s.b.index;
                if (n < 1501 || random.nextInt(5) > 0) {
                    int low = 0;
                    int high = first - 1;

                    while (low <= high) {
                        int mid = (low + high) / 2;
                        long area = triangle_area(s.a, s.b, points[mid]);
                        if (area == target_area) {
                            yes(out, s.a, s.b, points[mid]);
                            return;
                        }
                        if (area < target_area) {
                            high = mid - 1;
                        } else {
                            low = mid + 1;
                        }
                    }

                    low = second + 1;
                    high = n - 1;

                    while (low <= high) {
                        int mid = (low + high) / 2;
                        long area = triangle_area(s.a, s.b, points[mid]);
                        if (area == target_area) {
                            yes(out, s.a, s.b, points[mid]);
                            return;
                        }
                        if (area > target_area) {
                            high = mid - 1;
                        } else {
                            low = mid + 1;
                        }
                    }
                }
                points[second] = s.a;
                points[first] = s.b;
                points[first].index = first;
                points[second].index = second;
            }
            out.println("No");
        }

        private void yes(PrintWriter out, Point a, Point b, Point c) {
            out.printf("Yes\n");
            out.printf("%d %d\n", a.x, a.y);
            out.printf("%d %d\n", b.x, b.y);
            out.printf("%d %d\n", c.x, c.y);
        }

        class Point implements Comparable<Point> {
            int x;
            int y;
            int index;

            public Point(int x, int y) {
                this.x = x;
                this.y = y;
            }


            public int compareTo(Point o) {
                if (y == o.y) {
                    return Long.signum(o.x - this.x);
                } else {
                    return Long.signum(o.y - this.y);
                }
            }

        }

        class Segment {
            Point a;
            Point b;

            Segment(Point a, Point b) {
                this.a = a;
                this.b = b;
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            // InputMismatchException -> UnknownError
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            } else if (c == '+') {
                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;
        }

        public long readLong() {
            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;
        }

        public static boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}