import java.util.PriorityQueue;

public class Euler395 {
    static class Vec2 {
        double x, y;

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

    static double norm(Vec2 v) {
        return Math.sqrt(v.x * v.x + v.y * v.y);
    }

    static Vec2 applyTransposeMul(Vec2 d, Vec2 c) {
        return new Vec2(c.x * d.x + c.y * d.y, -c.y * d.x + c.x * d.y);
    }

    static double dot(Vec2 a, Vec2 b) {
        return a.x * b.x + a.y * b.y;
    }

    static double supportUnitSquare(Vec2 d) {
        return Math.max(0.0, Math.max(d.x, Math.max(d.y, d.x + d.y)));
    }

    static class Node implements Comparable<Node> {
        double upperBound;
        double offset;
        Vec2 dir;

        Node(double upperBound, double offset, Vec2 dir) {
            this.upperBound = upperBound;
            this.offset = offset;
            this.dir = dir;
        }

        @Override
        public int compareTo(Node o) {
            return Double.compare(o.upperBound, this.upperBound);
        }
    }

    static class SupportSolver {
        Vec2 a = new Vec2(16.0 / 25.0, 12.0 / 25.0);
        Vec2 b = new Vec2(9.0 / 25.0, -12.0 / 25.0);
        Vec2 t1 = new Vec2(0.0, 1.0);
        Vec2 t2 = new Vec2(16.0 / 25.0, 37.0 / 25.0);

        double support(Vec2 direction, double tol) {
            double kRadialBound = 5.0;
            double best = supportUnitSquare(direction);

            PriorityQueue<Node> pq = new PriorityQueue<>();
            pq.offer(new Node(norm(direction) * kRadialBound, 0.0, direction));

            while (!pq.isEmpty()) {
                Node cur = pq.poll();
                if (cur.upperBound <= best + tol)
                    continue;

                best = Math.max(best, cur.offset + supportUnitSquare(cur.dir));

                Vec2 dir1 = applyTransposeMul(cur.dir, a);
                double off1 = cur.offset + dot(cur.dir, t1);
                double ub1 = off1 + norm(dir1) * kRadialBound;
                if (ub1 > best + tol) {
                    pq.offer(new Node(ub1, off1, dir1));
                }

                Vec2 dir2 = applyTransposeMul(cur.dir, b);
                double off2 = cur.offset + dot(cur.dir, t2);
                double ub2 = off2 + norm(dir2) * kRadialBound;
                if (ub2 > best + tol) {
                    pq.offer(new Node(ub2, off2, dir2));
                }
            }
            return best;
        }
    }

    static String solve() {
        SupportSolver solver = new SupportSolver();
        double xmax = solver.support(new Vec2(1.0, 0.0), 1e-15);
        double xmin = -solver.support(new Vec2(-1.0, 0.0), 1e-15);
        double ymax = solver.support(new Vec2(0.0, 1.0), 1e-15);
        double ymin = -solver.support(new Vec2(0.0, -1.0), 1e-15);

        double area = (xmax - xmin) * (ymax - ymin);
        return String.format(java.util.Locale.US, "%.10f", area);
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}