public class Euler637 {

    static class BitMin {
        int n;
        int[] rightmost;
        int[] arr;

        BitMin(int[] initial) {
            this.n = initial.length - 1;
            this.rightmost = new int[8];
            for (int i = 0; i < 8; i++)
                rightmost[i] = -1;
            this.arr = initial;
        }

        int suffix_min(int i) {
            if (i == 0)
                return 0;
            for (int v = 0; v < rightmost.length; ++v) {
                if (rightmost[v] >= i)
                    return v;
            }
            return n;
        }

        void update(int i, int new_val) {
            if (new_val >= arr[i])
                return;
            arr[i] = new_val;
            seed(i, new_val);
        }

        void seed(int i, int val) {
            if (val < 0 || val >= n)
                return;
            if (val >= rightmost.length) {
                int next_size = rightmost.length;
                while (next_size <= val)
                    next_size <<= 1;
                int[] new_rm = new int[next_size];
                for (int j = 0; j < rightmost.length; ++j)
                    new_rm[j] = rightmost[j];
                for (int j = rightmost.length; j < next_size; ++j)
                    new_rm[j] = -1;
                rightmost = new_rm;
            }
            if (i > rightmost[val])
                rightmost[val] = i;
        }
    }

    static int[] f_steps(int n, int b) {
        int[] steps = new int[n + 1];
        for (int i = b; i <= n; ++i)
            steps[i] = n;
        int[] digit_sums = new int[n + 1];
        for (int i = 1; i <= n; ++i) {
            digit_sums[i] = digit_sums[i / b] + (i % b);
        }

        BitMin bit_min = new BitMin(steps);
        if (b > 1)
            bit_min.seed(b - 1, 0);

        int[] b_pows = new int[32];
        int pow_len = 0;
        for (long p = 1; p <= n; p *= b) {
            b_pows[pow_len++] = (int) p;
        }

        final int final_pow_len = pow_len;

        for (int k = b; k <= n; ++k) {
            int dsum = digit_sums[k];
            int[] current_min = { steps[dsum] + 1 };

            class Dfs {
                void run(int krem, int digit_sum_rem, int exp, int curr_part, int part_sum) {
                    int smallest = digit_sum_rem + part_sum + curr_part;
                    int cand = steps[smallest] + 1;
                    if (cand < current_min[0])
                        current_min[0] = cand;
                    if (bit_min.suffix_min(smallest) + 1 >= current_min[0])
                        return;
                    if (krem == 0)
                        return;

                    int digit = krem % b;
                    int next_k = krem / b;
                    int next_sum = digit_sum_rem - digit;
                    run(next_k, next_sum, 1, digit, part_sum + curr_part);
                    if (exp != 0 && exp < final_pow_len) {
                        run(next_k, next_sum, exp + 1,
                                curr_part + digit * b_pows[exp], part_sum);
                    }
                }
            }

            new Dfs().run(k, dsum, 0, 0, 0);

            bit_min.update(k, current_min[0]);
            steps[k] = current_min[0];
        }

        return steps;
    }

    static long g(int n, int b1, int b2) {
        int[] s1 = f_steps(n, b1);
        int[] s2 = (b1 == b2) ? s1 : f_steps(n, b2);

        long total = 0;
        for (int k = 1; k <= n; ++k) {
            if (s1[k] == s2[k])
                total += k;
        }
        return total;
    }

    public static String solve() {
        int n = 10000000;
        long ans = g(n, 10, 3);
        return Long.toString(ans);
    }

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