import java.util.*;

public class Euler332 {

    static class Point {
        int x, y, z;

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

    static double minSphericalTriangleArea(int r) {
        int rr = r * r;
        List<Point> points = new ArrayList<>();

        for (int x = -r; x <= r; x++) {
            int x2 = x * x;
            for (int y = -r; y <= r; y++) {
                int y2 = y * y;
                int z2 = rr - x2 - y2;
                if (z2 < 0)
                    continue;
                int z = (int) Math.round(Math.sqrt(z2));
                if (z * z != z2)
                    continue;
                points.add(new Point(x, y, z));
                if (z != 0) {
                    points.add(new Point(x, y, -z));
                }
            }
        }

        int n = points.size();
        if (n < 3)
            return 0.0;

        long[][] dots = new long[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                long v = (long) points.get(i).x * points.get(j).x +
                        (long) points.get(i).y * points.get(j).y +
                        (long) points.get(i).z * points.get(j).z;
                dots[i][j] = v;
                dots[j][i] = v;
            }
        }

        long bestDet = Long.MAX_VALUE;
        long bestDen = 1;

        long r2 = (long) r * r;
        long r3 = r2 * r;

        for (int i = 0; i < n; i++) {
            Point pi = points.get(i);
            for (int j = i + 1; j < n; j++) {
                Point pj = points.get(j);
                for (int k = j + 1; k < n; k++) {
                    Point pk = points.get(k);

                    long det = (long) pi.x * ((long) pj.y * pk.z - (long) pj.z * pk.y) -
                            (long) pi.y * ((long) pj.x * pk.z - (long) pj.z * pk.x) +
                            (long) pi.z * ((long) pj.x * pk.y - (long) pj.y * pk.x);

                    long detv = Math.abs(det);
                    if (detv == 0)
                        continue;

                    long sumDots = dots[i][j] + dots[i][k] + dots[j][k];
                    long denv = r3 + r * sumDots;

                    if (denv <= 0)
                        continue;

                    // detv/denv < bestDet/bestDen => detv*bestDen < bestDet*denv
                    // need using BigInteger or float point approximations, or simply rely on
                    // Math.multiplyHigh, but since values can be up to ~50^6 (1.5e10), detv *
                    // bestDen can be (~1.5e10)^2 = 2.25e20 which slightly exceeds Long.MAX_VALUE
                    // (9e18).
                    // We can use double division for quick check, then BigInteger if close, or just
                    // BigInteger.
                    if (bestDet == Long.MAX_VALUE || isLess(detv, denv, bestDet, bestDen)) {
                        bestDet = detv;
                        bestDen = denv;
                    }
                }
            }
        }

        if (bestDet == Long.MAX_VALUE)
            return 0.0;

        double omega = 2.0 * Math.atan2((double) bestDet, (double) bestDen);
        return r2 * omega;
    }

    static boolean isLess(long aNum, long aDen, long bNum, long bDen) {
        // aNum/aDen < bNum/bDen -> aNum*bDen < bNum*aDen
        java.math.BigInteger left = java.math.BigInteger.valueOf(aNum).multiply(java.math.BigInteger.valueOf(bDen));
        java.math.BigInteger right = java.math.BigInteger.valueOf(bNum).multiply(java.math.BigInteger.valueOf(aDen));
        return left.compareTo(right) < 0;
    }

    public static String solve() {
        double total = 0.0;
        for (int r = 1; r <= 50; r++) {
            total += minSphericalTriangleArea(r);
        }
        return String.format(Locale.US, "%.6f", total);
    }

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