import java.util.ArrayList;

public class Euler893 {

    static final int[] DIGIT_COST = { 6, 2, 5, 5, 4, 5, 6, 3, 7, 6 };

    static boolean improveMul(int[] m) {
        int N = m.length - 1;
        boolean changed = false;
        for (int x = 1; x <= N; ++x) {
            int cx = m[x];
            int maxY = N / x;
            for (int y = x; y <= maxY; ++y) {
                int prod = x * y;
                int cand = cx + m[y] + 2;
                if (cand < m[prod]) {
                    m[prod] = cand;
                    changed = true;
                }
            }
        }
        return changed;
    }

    static boolean improveAdd(int[] m) {
        int N = m.length - 1;
        int maxm = 0;
        for (int i = 1; i <= N; ++i) {
            if (m[i] > maxm)
                maxm = m[i];
        }

        @SuppressWarnings("unchecked")
        ArrayList<Integer>[] byCost = new ArrayList[maxm + 1];
        for (int i = 0; i <= maxm; i++) {
            byCost[i] = new ArrayList<>();
        }
        for (int n = 1; n <= N; ++n) {
            byCost[m[n]].add(n);
        }

        boolean changed = false;
        for (int ca = 0; ca <= maxm; ++ca) {
            ArrayList<Integer> A = byCost[ca];
            if (A.isEmpty())
                continue;
            for (int cb = ca; cb <= maxm; ++cb) {
                ArrayList<Integer> B = byCost[cb];
                if (B.isEmpty())
                    continue;
                int cand = ca + cb + 2;
                if (cand >= maxm)
                    break;

                if (ca == cb) {
                    for (int i = 0; i < A.size(); ++i) {
                        int x = A.get(i);
                        int limit = N - x;
                        for (int j = i; j < A.size(); ++j) {
                            int y = A.get(j);
                            if (y > limit)
                                break;
                            int s = x + y;
                            if (cand < m[s]) {
                                m[s] = cand;
                                changed = true;
                            }
                        }
                    }
                } else {
                    ArrayList<Integer> P = A;
                    ArrayList<Integer> Q = B;
                    if (P.size() > Q.size()) {
                        P = B;
                        Q = A;
                    }
                    for (int i = 0; i < P.size(); ++i) {
                        int x = P.get(i);
                        int limit = N - x;
                        for (int j = 0; j < Q.size(); ++j) {
                            int y = Q.get(j);
                            if (y > limit)
                                break;
                            int s = x + y;
                            if (cand < m[s]) {
                                m[s] = cand;
                                changed = true;
                            }
                        }
                    }
                }
            }
        }
        return changed;
    }

    public static String solve() {
        int N = 1000000;
        int[] m = new int[N + 1];
        for (int n = 1; n <= N; ++n) {
            m[n] = m[n / 10] + DIGIT_COST[n % 10];
        }
        while (improveMul(m)) {
        }
        while (improveAdd(m)) {
        }

        long sum = 0;
        for (int n = 1; n <= N; ++n) {
            sum += m[n];
        }
        return Long.toString(sum);
    }

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