public class Euler832 {
    static final long kMod = 1000000007L;
    static final long inv2 = (kMod + 1) / 2;

    static long modAdd(long a, long b) {
        long s = a + b;
        if (s >= kMod)
            s -= kMod;
        return s;
    }

    static long modMul(long a, long b) {
        return (a * b) % kMod;
    }

    static long rangeSumMod(long start, long len) {
        if (len == 0)
            return 0;
        long t1 = len % kMod;
        long t2 = (2 * (start % kMod) + (len - 1) % kMod) % kMod;
        return modMul(modMul(t1, t2), inv2);
    }

    static long fullBlockSum(long a, long b, long c, long size) {
        long s = 0;
        s = modAdd(s, rangeSumMod(a, size));
        s = modAdd(s, rangeSumMod(b, size));
        s = modAdd(s, rangeSumMod(c, size));
        return s;
    }

    static long partialBlockSum(long len, long a, long b, long c, long size) {
        if (len == 0)
            return 0;
        if (len == size)
            return fullBlockSum(a, b, c, size);
        if (size == 1)
            return (a + b + c) % kMod;

        long s = size / 4;
        long ans = 0;

        long l1 = Math.min(len, s);
        ans = modAdd(ans, partialBlockSum(l1, a, b, c, s));

        long rem = (len > s) ? len - s : 0;
        long l2 = Math.min(rem, s);
        ans = modAdd(ans, partialBlockSum(l2, a + s, b + 2 * s, c + 3 * s, s));

        rem = (len > 2 * s) ? len - 2 * s : 0;
        long l3 = Math.min(rem, s);
        ans = modAdd(ans, partialBlockSum(l3, a + 2 * s, b + 3 * s, c + s, s));

        rem = (len > 3 * s) ? len - 3 * s : 0;
        long l4 = Math.min(rem, s);
        ans = modAdd(ans, partialBlockSum(l4, a + 3 * s, b + s, c + 2 * s, s));

        return ans;
    }

    static long mFast(long n) {
        if (n == 0)
            return 0;

        long a = 1, b = 2, c = 3;
        long size = 1;
        long left = n;
        long ans = 0;

        while (left > size) {
            ans = modAdd(ans, fullBlockSum(a, b, c, size));
            left -= size;
            a *= 4;
            b *= 4;
            c *= 4;
            size *= 4;
        }

        ans = modAdd(ans, partialBlockSum(left, a, b, c, size));
        return ans;
    }

    public static String solve() {
        return Long.toString(mFast(1000000000000000000L));
    }

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