import java.math.BigInteger;
import java.util.Arrays;

public class Euler538 {
    static int popcount(long x) {
        return Long.bitCount(x);
    }

    static class Fenwick {
        int n;
        int[] bit;

        Fenwick(int n) {
            this.n = n;
            this.bit = new int[n + 1];
        }

        void add(int idx, int delta) {
            for (int i = idx + 1; i <= n; i += i & -i) {
                bit[i] += delta;
            }
        }

        int sumPrefix(int idx) {
            int res = 0;
            for (int i = idx; i > 0; i -= i & -i) {
                res += bit[i];
            }
            return res;
        }

        int kth(int k) {
            int idx = 0;
            int bitMask = 1;
            while ((bitMask << 1) <= n) {
                bitMask <<= 1;
            }
            for (int step = bitMask; step > 0; step >>= 1) {
                int next = idx + step;
                if (next <= n && bit[next] <= k) {
                    k -= bit[next];
                    idx = next;
                }
            }
            return idx;
        }
    }

    public static String solve() {
        int N = 3000000;
        long[] pow2 = new long[25];
        for (int i = 0; i <= 24; i++)
            pow2[i] = 1L << i;
        long[] pow3 = new long[25];
        pow3[0] = 1;
        for (int i = 1; i <= 24; i++)
            pow3[i] = pow3[i - 1] * 3L;

        long[] U = new long[N];
        for (int n = 1; n <= N; n++) {
            int b3 = popcount(3L * n);
            int b2 = popcount(2L * n);
            int b1 = popcount(n + 1L);
            U[n - 1] = pow2[b3] + pow3[b2] + b1;
        }

        long[] vals = U.clone();
        Arrays.sort(vals);
        int uniqueCount = 1;
        for (int i = 1; i < vals.length; i++) {
            if (vals[i] != vals[i - 1]) {
                vals[uniqueCount++] = vals[i];
            }
        }
        vals = Arrays.copyOf(vals, uniqueCount);

        Fenwick fw = new Fenwick(vals.length);
        int[] cnt = new int[vals.length];

        BigInteger bestScore = BigInteger.ZERO;
        long bestPer = 0;
        BigInteger ans = BigInteger.ZERO;

        for (int n = 1; n <= N; n++) {
            long v = U[n - 1];
            int idx = Arrays.binarySearch(vals, v);

            int prefixLess = fw.sumPrefix(idx);
            int pos = prefixLess + cnt[idx];

            cnt[idx]++;
            fw.add(idx, 1);

            if (n >= 4) {
                int lo = Math.max(0, pos - 3);
                int hi = Math.min(n - 1, pos + 3);
                long[] win = new long[hi - lo + 1];
                for (int p = lo; p <= hi; p++) {
                    int id = fw.kth(p);
                    win[p - lo] = vals[id];
                }

                int startMin = Math.max(0, pos - 3);
                int startMax = Math.min(pos, n - 4);
                for (int s = startMin; s <= startMax; s++) {
                    int off = s - lo;
                    long a = win[off];
                    long b = win[off + 1];
                    long c = win[off + 2];
                    long d = win[off + 3];

                    if (d >= a + b + c)
                        continue;
                    long su = a + b + c + d;

                    BigInteger f1 = BigInteger.valueOf(su - 2 * a);
                    BigInteger f2 = BigInteger.valueOf(su - 2 * b);
                    BigInteger f3 = BigInteger.valueOf(su - 2 * c);
                    BigInteger f4 = BigInteger.valueOf(su - 2 * d);

                    BigInteger sc = f1.multiply(f2).multiply(f3).multiply(f4);

                    int cmp = sc.compareTo(bestScore);
                    if (cmp > 0 || (cmp == 0 && su > bestPer)) {
                        bestScore = sc;
                        bestPer = su;
                    }
                }

                ans = ans.add(BigInteger.valueOf(bestPer));
            }
        }

        return ans.toString();
    }

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