import java.io.PrintWriter;
import java.io.FileOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.*;

public class polygon_petr {
    final static double EPS = 1e-12;

    static class Point {
        public final double x;
        public final double y;

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

        double distance(Point p) {
            double dx = x - p.x;
            double dy = y - p.y;
            return Math.sqrt(dx * dx + dy * dy);
        }
    }

    static class Line {
        public final double a;
        public final double b;
        public final double c;

        public Line(double a, double b, double c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        public Line(Point p1, Point p2) {
            double ta = p1.y - p2.y;
            double tb = p2.x - p1.x;
            double z = Math.sqrt(ta * ta + tb * tb);
            a = ta / z;
            b = tb / z;
            c = -(a * p1.x + b * p1.y);
        }

        Line perpendicular(Point from) {
            return new Line(b, -a, -(b * from.x - a * from.y));
        }

        int side(Point p) {
            double z = a * p.x + b * p.y + c;
            if (Math.abs(z) < EPS)
                return 0;
            else if (z < 0)
                return -1;
            else
                return 1;
        }

        static Point crossLines(Line l1, Line l2) {
            double z = l1.a * l2.b - l1.b * l2.a;
            if (Math.abs(z) < EPS)
                return null;
            return new Point(
                    (-l1.c * l2.b + l1.b * l2.c) / z,
                    (-l1.a * l2.c + l1.c * l2.a) / z
            );
        }

        Point crossSegment(Point p1, Point p2) {
            int s1 = side(p1);
            int s2 = side(p2);

            if (s1 == 0)
                return p1;
            if (s2 == 0)
                return p2;
            if (s1 == s2)
                return null;

            return crossLines(this, new Line(p1, p2));
        }

        static Line bisector(Line l1, Line l2) {
            if (l1.a * l2.a + l1.b * l2.b > 0)
                return new Line(l1.a + l2.a, l1.b + l2.b, l1.c + l2.c);
            else
                return new Line(l1.a - l2.a, l1.b - l2.b, l1.c - l2.c);
        }
    }

    Point origin = new Point(0, 0);

    Point[] polygon;

    double result;

    void readInput() throws FileNotFoundException {
        Scanner scanner = new Scanner(new File("polygon.in"));
        scanner.useLocale(Locale.ENGLISH);

        int numVertices = scanner.nextInt();

        polygon = new Point[numVertices];

        for (int i = 0; i < numVertices; ++i) {
            double x = scanner.nextDouble();
            double y = scanner.nextDouble();
            polygon[i] = new Point(x, y);
        }
    }

    void writeOutput() throws FileNotFoundException {
        PrintWriter writer = new PrintWriter(new FileOutputStream("polygon.out"));
        writer.println(result);
        writer.close();
    }

    void checkLine(Line line) {
        double dMin = Double.MAX_VALUE;
        double dMax = Double.MIN_VALUE;
        boolean any = false;

        for (int i = 0; i < polygon.length; ++i) {
            Point p1 = polygon[i];
            Point p2 = polygon[(i + 1) % polygon.length];

            Point p = line.crossSegment(p1, p2);

            if (p != null) {
                double d = origin.distance(p);
                if (d < dMin)
                    dMin = d;
                if (d > dMax)
                    dMax = d;
                any = true;
            }
        }

        if (any) {
            double cur = dMin * dMax;
            if (cur < result)
                result = cur;
        }
    }

    void solve() {
        result = Double.MAX_VALUE;

        for (Point point : polygon)
            checkLine(new Line(origin, point));

        Line[] sides = new Line[polygon.length];

        for (int i = 0; i < polygon.length; ++i) {
            sides[i] = new Line(
                    polygon[i],
                    polygon[(i + 1) % polygon.length]
            );
        }

        for (int i = 0; i < sides.length; ++i)
            for (int j = i + 1; j < sides.length; ++j) {
                Line line = Line.bisector(sides[i], sides[j]).perpendicular(origin);
                checkLine(line);
                line = line.perpendicular(origin);
                checkLine(line);
            }
    }

    void run() throws FileNotFoundException {
        readInput();
        solve();
        writeOutput();
    }

    public static void main(String[] args) throws FileNotFoundException {
        new polygon_petr().run();
    }
}
