#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int ll

#define REP(i,n) for(ll i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#  define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#  define DBG(fmt, ...)
#endif

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const int MOD = 1000000007;
#define MAX_N 100010
#define MAX_D 64

ll N;
ll msb;
#ifdef TLE
ll dp[MAX_D][MAX_N] = {};
#else
ll dp[MAX_D][3] = {};
#endif

// 最上位ビット(MSB) が右から何番目かを求める (0-indexed)
static inline ll Msb(ll num) {
    ll res = 0;
    for(int i = 0; i < 64; ++i) { if((num >> i) & 1) { res = i; } }
    return res;
}

#ifdef TLE
// 左から見て i 番目のビットを見ていて、現在の値が j のときのパターン数
// j が最終的に v (= a + b) を指す
ll dfs(int i = 0, int j = 0) {
    if(i > msb) {
        // j が N を超えてしまうと v として不成立
        if(j > N) { return 0; }
        else { return 1; }
    }
    ll& res = dp[i][j];
    if(~res) { return res; }
    res = 0;
    // a の i 番目が 1 で、 b の i 番目が 1 のとき
    res += dfs(i + 1, j + (2 << (msb - i)));
    res %= MOD;
    // a か b どちらかが 1 で、どちらかが 0 のとき
    // ここを 1 回だけのカウントにすることで、違う a, b の組で u, v がかぶることがなくなる
    res += dfs(i + 1, j + (1 << (msb - i)));
    res %= MOD;
    // どちらも 0 のとき
    res += dfs(i + 1, j);
    res %= MOD;
    return res;
}
#else
// 現在左から i 番目のビットを見ていて、
// 次の dfs でどのパターンを見るかを j としたときのパターン数
// j == 0 : 前の前の桁のビットが一緒だし、前の桁のビットも一緒（余裕なし）
// j == 1 : 前の前の桁のビットは一緒だが、前のビットは N より 1 小さい
// j == 2 : 前の前の桁のビットが 1 小さい（全パターンいける）
ll dfs(int i = 0, int j = 0) {
    if(i > msb) {
        // あり得るパターンしかなぞらないので必ず return 1
        return 1;
    }
    ll& res = dp[i][j];
    if(~res) { return res; }
    res = 0;
    ll cur = (N >> (msb - i)) & 1;  // 現在みているビット
    if(j == 0) {
        if(cur == 0) {
            // もう足すことは許されない
            res += dfs(i + 1, 0);
            res %= MOD;
        } else {
            // a の i 番目が 1 で、 b の i 番目が 1 のとき
            // -> 無理
            // a か b どちらかが 1 で、どちらかが 0 のとき
            // -> この桁で 1 にすると、次の桁で余裕がなくなる
            res += dfs(i + 1, 0);
            res %= MOD;
            // どちらも 0 のとき
            // -> この桁で 0 のままなら、次の桁は多少余裕がある
            res += dfs(i + 1, 1);
            res %= MOD;
        }

    }
    else if(j == 1) {
        if(cur == 0) {
            // a の i 番目が 1 で、 b の i 番目が 1 のとき
            // -> 今回はいけるが、次は余裕がなくなる
            res += dfs(i + 1, 0);
            res %= MOD;
            // a か b どちらかが 1 で、どちらかが 0 のとき
            // -> この桁で繰り上がると、次でまた繰り上がったときにやばい
            res += dfs(i + 1, 1);
            res %= MOD;
            // どちらも 0 のとき
            // -> もう N に追いつくことはない
            res += dfs(i + 1, 2);
            res %= MOD;
        } else {
            // a の i 番目が 1 で、 b の i 番目が 1 のとき
            // -> この桁で繰り上がると、次でまた繰り上がったときにやばい
            res += dfs(i + 1, 1);
            res %= MOD;
            // a か b どちらかが 1 で、どちらかが 0 のとき
            // -> もう N に追いつくことはない
            res += dfs(i + 1, 2);
            res %= MOD;
            // どちらも 0 のとき
            // -> もう N に追いつくことはない
            res += dfs(i + 1, 2);
            res %= MOD;
        }
    }
    else {
        // ここ以降ビットが 1 だろうが 0 だろうが全パターン試すことができる
        res += dfs(i + 1, 2);
        res %= MOD;
        res += dfs(i + 1, 2);
        res %= MOD;
        res += dfs(i + 1, 2);
        res %= MOD;
    }
    return res;
}
#endif

signed main()
{
    cin >> N;
    msb = Msb(N);

    MINUS(dp);
    ll ans = dfs();
    printf("%lld\n", ans);

    return 0;
}


Measured memory_bytes: 256