import java.util.*;

public class Euler68 {
    private static boolean runCheckpoints = true;

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

    private static long solve() {
        int[] nums = new int[10];
        for (int i = 0; i < 10; ++i) {
            nums[i] = i + 1;
        }

        String best = "";

        // Choose inner ring (5 numbers in cyclic order), derive outer ring from line sums.
        int[] mask = new int[10];
        Arrays.fill(mask, 0, 5, 1);
        Arrays.fill(mask, 5, 10, 0);

        do {
            List<Integer> innerSet = new ArrayList<>();
            List<Integer> outerSet = new ArrayList<>();

            for (int i = 0; i < 10; ++i) {
                if (mask[i] == 1) {
                    innerSet.add(nums[i]);
                } else {
                    outerSet.add(nums[i]);
                }
            }

            Collections.sort(innerSet);
            do {
                final int i1 = innerSet.get(0);
                final int i2 = innerSet.get(1);
                final int i3 = innerSet.get(2);
                final int i4 = innerSet.get(3);
                final int i5 = innerSet.get(4);

                for (final int o1 : outerSet) {
                    final int targetSum = o1 + i1 + i2;

                    final int o2 = targetSum - i2 - i3;
                    final int o3 = targetSum - i3 - i4;
                    final int o4 = targetSum - i4 - i5;
                    final int o5 = targetSum - i5 - i1;

                    int[] outer = {o1, o2, o3, o4, o5};
                    Set<Integer> outerNeeded = new HashSet<>(outerSet);

                    boolean ok = true;
                    for (final int o : outer) {
                        if (!outerNeeded.remove(o)) {
                            ok = false;
                            break;
                        }
                    }
                    if (!ok) {
                        continue;
                    }

                    int minOuter = Arrays.stream(outer).min().orElse(Integer.MAX_VALUE);
                    if (outer[0] != minOuter) {
                        continue;
                    }

                    StringBuilder repr = new StringBuilder();
                    java.util.function.Consumer<int[]> appendLine = arr -> {
                        repr.append(arr[0]).append(arr[1]).append(arr[2]);
                    };

                    appendLine.accept(new int[]{outer[0], i1, i2});
                    appendLine.accept(new int[]{outer[1], i2, i3});
                    appendLine.accept(new int[]{outer[2], i3, i4});
                    appendLine.accept(new int[]{outer[3], i4, i5});
                    appendLine.accept(new int[]{outer[4], i5, i1});

                    if (repr.length() == 16 && repr.toString().compareTo(best) > 0) {
                        best = repr.toString();
                    }
                }
            } while (nextPermutation(innerSet));

        } while (prevPermutation(mask));

        return Long.parseLong(best);
    }

    private static boolean nextPermutation(List<Integer> list) {
        int i = list.size() - 2;
        while (i >= 0 && list.get(i) >= list.get(i + 1)) {
            i--;
        }
        if (i < 0) return false;

        int j = list.size() - 1;
        while (list.get(j) <= list.get(i)) {
            j--;
        }

        Collections.swap(list, i, j);
        Collections.reverse(list.subList(i + 1, list.size()));
        return true;
    }

    private static boolean prevPermutation(int[] array) {
        int i = array.length - 2;
        while (i >= 0 && array[i] <= array[i + 1]) {
            i--;
        }
        if (i < 0) return false;

        int j = array.length - 1;
        while (array[j] >= array[i]) {
            j--;
        }

        swap(array, i, j);
        reverse(array, i + 1, array.length - 1);
        return true;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private static void reverse(int[] array, int start, int end) {
        while (start < end) {
            swap(array, start, end);
            start++;
            end--;
        }
    }

    private static boolean runCheckpoints() {
        final long value = solve();
        if (value == 0L) {
            System.err.println("Checkpoint failed for non-zero result");
            return false;
        }
        return true;
    }

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

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