import java.util.Arrays;

public class Euler461 {
    static class IntPair {
        int first;
        int second;

        IntPair(int f, int s) {
            first = f;
            second = s;
        }
    }

    static IntPair closestSum(double[] x, int xSize, double[] y, int ySize, double target, double deltaStart) {
        if (xSize == 0 || ySize == 0)
            return null;

        int bestI = -1;
        int bestJ = -1;
        double bestDelta = deltaStart;

        int j = ySize - 1;
        for (int i = 0; i < xSize; i++) {
            if (j < 0)
                break;
            if (x[i] + y[j] < target - bestDelta)
                continue;

            while (j >= 0 && x[i] + y[j] > target && x[i] <= y[j]) {
                j--;
            }

            if (j < 0 || x[i] > y[j])
                break;

            int candJ = j;
            double delta = target - x[i] - y[candJ];

            if (j < ySize - 1 && x[i] + y[j + 1] > target) {
                double tempDelta = x[i] + y[j + 1] - target;
                if (tempDelta < delta) {
                    candJ = j + 1;
                    delta = tempDelta;
                }
            }

            if (delta < bestDelta) {
                bestDelta = delta;
                bestI = i;
                bestJ = candJ;
            }
        }

        if (bestI < 0 || bestJ < 0)
            return null;
        return new IntPair(bestI, bestJ);
    }

    public static String solve() {
        int n = 10000;
        double pi = Math.PI;
        int bound = (int) Math.floor(n * Math.log(pi + 0.1));
        double[] values = new double[bound + 1];

        for (int a = 0; a <= bound; a++) {
            values[a] = Math.exp((double) a / n) - 1.0;
        }

        double deltaLimit = 0.001;

        int estimatedSize = 25000000;
        double[] smallSums = new double[estimatedSize];
        int smallSize = 0;

        for (int a = 0; a <= bound; a++) {
            double ea = values[a];
            if (4.0 * ea > pi + deltaLimit)
                break;
            for (int b = a; b <= bound; b++) {
                double eb = values[b];
                if (ea + 3.0 * eb > pi + deltaLimit)
                    break;

                if (smallSize == smallSums.length) {
                    double[] nextSmall = new double[smallSums.length * 2];
                    System.arraycopy(smallSums, 0, nextSmall, 0, smallSize);
                    smallSums = nextSmall;
                }

                smallSums[smallSize++] = ea + eb;
            }
        }

        double[] largeSums = new double[estimatedSize];
        int largeSize = 0;

        for (int d = bound; d >= 0; d--) {
            double ed = values[d];
            if (ed > pi + deltaLimit)
                continue;
            if (4.0 * ed < pi - deltaLimit)
                break;

            for (int c = d; c >= 0; c--) {
                double ec = values[c];
                if (ec + ed > pi + deltaLimit)
                    continue;
                if (ed + 3.0 * ec < pi - deltaLimit)
                    break;

                if (largeSize == largeSums.length) {
                    double[] nextLarge = new double[largeSums.length * 2];
                    System.arraycopy(largeSums, 0, nextLarge, 0, largeSize);
                    largeSums = nextLarge;
                }

                largeSums[largeSize++] = ec + ed;
            }
        }

        Arrays.parallelSort(smallSums, 0, smallSize);
        Arrays.parallelSort(largeSums, 0, largeSize);

        IntPair ijOpt = closestSum(smallSums, smallSize, largeSums, largeSize, pi, deltaLimit);
        if (ijOpt == null)
            return "0";

        IntPair abOpt = closestSum(values, values.length, values, values.length, smallSums[ijOpt.first], 0.001);
        IntPair cdOpt = closestSum(values, values.length, values, values.length, largeSums[ijOpt.second], 0.001);

        if (abOpt == null || cdOpt == null)
            return "0";

        int[] idx = { abOpt.first, abOpt.second, cdOpt.first, cdOpt.second };
        Arrays.sort(idx);

        long res = (long) idx[0] * idx[0] +
                (long) idx[1] * idx[1] +
                (long) idx[2] * idx[2] +
                (long) idx[3] * idx[3];

        return Long.toString(res);
    }

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