import java.util.HashMap;

public class Euler887 {

    static class BoundedSearch {
        long limit;
        HashMap<Long, Long>[] memo;

        @SuppressWarnings("unchecked")
        BoundedSearch(long limit) {
            this.limit = limit;
            memo = new HashMap[128];
            for (int i = 0; i < 128; i++) {
                memo[i] = new HashMap<>(4096);
            }
        }

        long F(int m, long d) {
            if (d < -1)
                return 0;
            if (d > limit)
                d = limit;
            if (m == 0)
                return 1;
            if (d == -1)
                return 1;
            if (d >= m - 1) {
                if (m >= 63)
                    return limit;
                long full = 1L << m;
                return Math.min(full, limit);
            }

            long key = d + 1;
            if (memo[m].containsKey(key)) {
                return memo[m].get(key);
            }

            long y = F(m - 1, d - 1);
            long d2 = y + d - 1;
            long z = F(m - 1, d2);

            long ans = y + z;
            if (ans > limit || ans < 0)
                ans = limit; // check overflow
            memo[m].put(key, ans);
            return ans;
        }

        int Q(long n, int d) {
            if (d == 0)
                return (int) (n - 1);
            int m = 0;
            while (F(m, d) < n)
                ++m;
            return m;
        }
    }

    public static String solve() {
        long L = 1;
        for (int i = 0; i < 10; ++i)
            L *= 7L;

        BoundedSearch bs = new BoundedSearch(L);

        // Using BigInteger for ans to avoid overflow
        java.math.BigInteger bL = java.math.BigInteger.valueOf(L);
        java.math.BigInteger ans = bL.multiply(bL.subtract(java.math.BigInteger.ONE))
                .divide(java.math.BigInteger.valueOf(2));

        for (int d = 1; d <= 7; ++d) {
            long prev = 0;
            int m = 0;
            while (prev < L) {
                long cur = bs.F(m, d);
                long upto = Math.min(cur, L);

                java.math.BigInteger bUpto = java.math.BigInteger.valueOf(upto);
                java.math.BigInteger bPrev = java.math.BigInteger.valueOf(prev);
                java.math.BigInteger bM = java.math.BigInteger.valueOf(m);

                ans = ans.add(bM.multiply(bUpto.subtract(bPrev)));

                prev = upto;
                ++m;
            }
        }

        return ans.toString();
    }

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