import java.util.*;

public class Euler61 {
    private static class Options {
        boolean runCheckpoints = true;
    }

    private static boolean parseArguments(String[] args, Options options) {
        for (int i = 0; i < args.length; ++i) {
            String arg = args[i];
            if (arg.equals("--skip-checkpoints")) {
                options.runCheckpoints = false;
                continue;
            }
            System.err.println("Unknown argument: " + arg);
            return false;
        }
        return true;
    }

    private static long polygonal(int type, int n) {
        switch (type) {
            case 3: return (long)n * (n + 1) / 2;
            case 4: return (long)n * n;
            case 5: return (long)n * (3 * n - 1) / 2;
            case 6: return (long)n * (2 * n - 1);
            case 7: return (long)n * (5 * n - 3) / 2;
            case 8: return (long)n * (3 * n - 2);
            default: return -1;
        }
    }

    private static List<Integer> generateFourDigitValues(int type) {
        List<Integer> values = new ArrayList<>();
        for (int n = 1;; ++n) {
            long x = polygonal(type, n);
            if (x > 9999) {
                break;
            }
            if (x >= 1000) {
                int value = (int)x;
                int prefix = value / 100;
                int suffix = value % 100;
                if (prefix >= 10 && suffix >= 10) {
                    values.add(value);
                }
            }
        }
        return values;
    }

    private static int solve() {
        int[] types = {3, 4, 5, 6, 7, 8};
        @SuppressWarnings("unchecked")
        List<Integer>[] nums = new List[6];
        for (int i = 0; i < 6; ++i) {
            nums[i] = generateFourDigitValues(types[i]);
        }

        List<Integer> chosenValues = new ArrayList<>();
        List<Integer> chosenTypes = new ArrayList<>();
        int[] answerRef = {-1};

        class DfsHelper {
            void dfs(int suffixNeeded, int usedMask, int firstPrefix, int currentSum) {
                if (answerRef[0] != -1) {
                    return;
                }
                if (chosenValues.size() == 6) {
                    if (suffixNeeded == firstPrefix) {
                        answerRef[0] = currentSum;
                    }
                    return;
                }

                for (int t = 0; t < 6; ++t) {
                    if (((usedMask >> t) & 1) != 0) {
                        continue;
                    }

                    for (int value : nums[t]) {
                        int prefix = value / 100;
                        int suffix = value % 100;

                        if (!chosenValues.isEmpty() && prefix != suffixNeeded) {
                            continue;
                        }

                        chosenValues.add(value);
                        chosenTypes.add(t);

                        int nextFirstPrefix = chosenValues.size() == 1 ? prefix : firstPrefix;
                        dfs(suffix, usedMask | (1 << t), nextFirstPrefix, currentSum + value);

                        chosenTypes.remove(chosenTypes.size() - 1);
                        chosenValues.remove(chosenValues.size() - 1);
                    }
                }
            }
        }

        DfsHelper helper = new DfsHelper();
        helper.dfs(-1, 0, -1, 0);
        return answerRef[0];
    }

    private static boolean runCheckpoints() {
        if (polygonal(3, 45) != 1035 || polygonal(8, 19) != 1045) {
            System.err.println("Checkpoint failed for polygonal formulas");
            return false;
        }
        return true;
    }

    public static void main(String[] args) {
        Options options = new Options();
        if (!parseArguments(args, options)) {
            System.exit(1);
        }
        if (options.runCheckpoints && !runCheckpoints()) {
            System.exit(2);
        }

        System.out.println(solve());
    }
}