import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class shepherd_as {
    final double EPS = 1e-9;

    class Point {
        double x;
        double y;


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

    class Circle {
        double x;
        double y;
        double r;

        public Circle(double x, double y, double r) {
            this.x = x;
            this.y = y;
            this.r = r;
        }

        public Circle(double x1, double y1, double x2, double y2, double r) {
            double d = hypot(x1 - x2, y1 - y2);
            double dx = (x2 - x1) / d;
            double dy = (y2 - y1) / d;
            double dd = sqrt(r * r - d * d / 4);
            x = x1 + dx * (d / 2) - dy * dd;
            y = y1 + dy * (d / 2) + dx * dd;
            this.r = r;
        }

        Point[] intersect(Circle o) {
            double A = 2 * (o.x - x);
            double B = 2 * (o.y - y);
            double C = (x * x - o.x * o.x) + (y * y - o.y * o.y) + (o.r * o.r - r * r);
            double D = A * A + B * B;
            if (abs(D) < EPS) {
                return new Point[]{};
            }
            double x0 = - A * C / D;
            double y0 = - B * C / D;
            double dx = -B / sqrt(D);
            double dy = A / sqrt(D);

            double a = 1.0;
            double b = 2 * (x0 - x) * dx + 2 * (y0 - y) * dy;
            double c = (x0 - x) * (x0 - x) + (y0 - y) * (y0 - y) - r * r;
            double d = b * b - 4 * a * c;
            if (d < -EPS) {
                return new Point[]{};
            }
            if (d < EPS) {
                double t = -b / (2 * a);
                double x = x0 + dx * t;
                double y = y0 + dy * t;
                return new Point[]{new Point(x, y)};
            }

            double t = (-b + sqrt(d)) / (2 * a);
            double x = x0 + dx * t;
            double y = y0 + dy * t;
            Point p1 = new Point(x, y);
            t = (-b - sqrt(d)) / (2 * a);
            x = x0 + dx * t;
            y = y0 + dy * t;
            Point p2 = new Point(x, y);
            return new Point[]{p1, p2};
        }
    }

    int n;
    double[] x;
    double[] y;
    double D;
    double d;

    ArrayList<Circle> createCircles(double ang) {
        ArrayList<Circle> cc = new ArrayList<Circle>();

        for (int i = 0; i < n; i++) {
            cc.add(new Circle(x[i], y[i], d));
            cc.add(new Circle(x[i], y[i], D));
        }

        for (int j = 0; j < n; j++) {
            for (int k = 0; k < n; k++) {
                if (j != k) {
                    double d = hypot(x[j] - x[k], y[j] - y[k]);
                    double r = (d / 2) / sin(ang);
                    cc.add(new Circle(x[j], y[j], x[k], y[k], r));
                }
            }
        }

        return cc;
    }

    boolean fit(Point p, double ang) {
        for (int i = 0; i < n; i++) {
            double dist = hypot(x[i] - p.x, y[i] - p.y);
            if (dist < d - EPS || dist > D + EPS) {
                return false;
            }
        }

        double[] an = new double[n];
        for (int i = 0; i < n; i++) {
            an[i] = atan2(y[i] - p.y, x[i] - p.x);
        }

        Arrays.sort(an);

        double maxda = 0;
        for (int i = 0; i < n; i++) {
            double da = an[(i + 1) % n] - an[i];
            if (da < 0) {
                da += 2 * PI;
            }
            if (da > maxda) {
                maxda = da;
            }
        }

        if (2 * PI - maxda < ang + EPS) {
            return true;
        } else {
            return false;
        }
    }

    Point findPoint(ArrayList<Circle> cc, double ang) {
        for (int i = 0; i < cc.size(); i++) {
            Circle c = cc.get(i);
            for (int j = i + 1; j < cc.size(); j++) {
                Circle d = cc.get(j);
                Point[] pp = c.intersect(d);
                for (Point p : pp) {
                    if (fit(p, ang)) {
                        return p;
                    }
                }
            }
        }
        return null;
    }



    public void run() throws IOException {
        Scanner in = new Scanner(new File("shepherd.in"));
        PrintWriter out = new PrintWriter(new File("shepherd.out"));

        n = in.nextInt();
        d = in.nextInt();
        D = in.nextInt();
        assert d <= D;

        x = new double[n];
        y = new double[n];

        for (int i = 0; i < n; i++) {
            x[i] = in.nextInt();
            y[i] = in.nextInt();
        }

        boolean oneLine = true;
        for (int i = 2; i < n; i++) {
            if ((x[i] - x[0]) * (y[1] - y[0]) != (x[1] - x[0]) * (y[i] - y[0])) {
                oneLine = false;
                break;
            }
        }

        if (oneLine) {
        	assert false;
            double md = 0;
            int bi = 0;
            int bj = 0;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    double dist = hypot(x[i] - x[j], y[i] - y[j]);
                    if (dist > md) {
                        md = dist;
                        bi = i;
                        bj = j;
                    }
                }
            }

            if (md + d < D + EPS) {
                double xp = x[bi] + (x[bj] - x[bi]) / md * (md + d);
                double yp = y[bi] + (y[bj] - y[bi]) / md * (md + d);
                out.printf("%.10f %.10f\n", xp, yp);
                out.close();
                return;
            }
        }

        double lo = 0;
        double hi = PI;

        for (int i = 0; i < 50; i++) {
            double ang = (lo + hi) / 2;

            ArrayList<Circle> cc = createCircles(ang);

            Point p = findPoint(cc, ang);
            if (p != null) {
                hi = ang;
            } else {
                lo = ang;
            }
        }

        Point p = findPoint(createCircles(hi), hi);
        if (p == null) {
            out.println("impossible");
        } else {
            out.printf("%.15f %.15f\n", p.x, p.y);
        }


        in.close();
        out.close();
    }

    public static void main(String[] arg) throws IOException {
    	Locale.setDefault(Locale.US);
        new shepherd_as().run();
    }
}
