#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <functional>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    int64_t tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (int64_t)value;
    return output;
}

namespace std {
    template<> class hash<int128_t>{
        public:
        size_t operator () ( const int128_t &x ) const {
            int64_t INF64 = std::numeric_limits<int64_t>::max();
            int64_t y1 = x / INF64;
            int64_t y2 = x % INF64;
            return hash<int64_t>()(y1) ^ hash<int64_t>()(y2);
        }
    };
}

int128_t imax(const int128_t a, const int128_t b) { return std::max(a, b); } // std::max, std::min は型が違うとエラーになるため、ラッパーを作る。
int128_t imin(const int128_t a, const int128_t b) { return std::min(a, b); }

#define rep(i, begin, end) for(int64_t i = ((int64_t)begin); i <= ((int64_t)end); i++) // (int64_t)end としておくと、end = v.size() - 2 みたいな入力で、v.size()が1でも正常(end = -1になる）に挙動する。
#define rev(i, begin, end) for(int64_t i = ((int64_t)begin); ((int64_t)end) <= i; i--)

#define input1(begin, end, v1) v1.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i]; }
#define input2(begin, end, v1, v2) v1.resize((end)+1); v2.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i]; } 
#define input3(begin, end, v1, v2, v3) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i]; }
#define input4(begin, end, v1, v2, v3, v4) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i]; } 
// input_arrayはbegin = 0のときのみ動作確認。Aの要素の型をテンプレートにして関数にしたほうが丁寧かもしれない。
#define input_array(begin, N, M, A) A.resize((begin)+(N)); for (int i = 0; i < (begin)+(N); i++) { A[i].resize((begin)+(M)); } for (int i = begin; i < (begin)+(N); i++) { for (int j = begin; j < (begin)+(M); j++) { std::cin >> A[i][j]; }}

std::vector<int> irange(const int begin, const int end) {
    std::vector<int> ret; for (int i = begin; i <= end; i++) { ret.push_back(i); }
    return ret;
}

template <typename T>
void printvec(const std::vector<T>& vec) {
    for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
}

std::vector<int> digit(int128_t n, const int128_t b) {
    // 基数bでの表示。0は0桁。非常に大きい数を入れても問題ないようにint128_tとする。
    // size()をとれば桁数になる。
    assert(1 < b);
    std::vector<int> ret;
    while (0 < n) {
        ret.push_back(n % b);
        n /= b;
    }
    return ret;
}

std::vector<int> digR, digL;

//--code begin--

int128_t L, R;
//std::vector<int128_t> ;
//std::string ;
//std::vector<std::string> ;
//double ;
//std::vector<double> ;

//const int128_t MAX_N = ;
const int128_t MOD = 1e9 + 7;
//const int128_t INF = std::numeric_limits<int64_t>::max();
//using pair = std::pair<int64_t, int>;

int128_t msbR, msbL;

int128_t solve(int128_t msb) {
    if (msb < msbL || msbR < msb) {
        return 0;
    }
    assert(msbL <= msb && msb <= msbR);

    int128_t dp[70][2][2] = {}; // dp[i][x][y] : i桁まで見て、xの条件が確定or未確定、yの条件が確定or未確定の状態数。

    if (msb == msbL && msb == msbR) {
        dp[msb][0][0] = 1;
    } else if (msbL < msb && msb == msbR) {
        dp[msb][1][0] = 1;
    } else if (msbL == msb && msb < msbR) {
        dp[msb][0][1] = 1;
    } else if (msbL < msb && msb < msbR) {
        dp[msb][1][1] = 1;
    } else {
        assert(false);
    }

    rev (i, msb - 1, 0) {
        rep (px, 0, 1) { rep (py, 0, 1) {
            rep (xb, 0, 1) { rep (yb, 0, 1) {
                if (yb == 0 && xb == 1) { continue; }

                int128_t nx = px;
                if (nx == 0) {
                    int128_t tL = (L >> i) & 1;
                    if (tL == 1 && xb == 0) {
                        continue;
                    } else if (tL == 0 && xb == 1) {
                        nx = 1;
                    }
                }

                int128_t ny = py;
                if (ny == 0) {
                    int128_t tR = (R >> i) & 1;
                    if (tR == 0 && yb == 1) {
                        continue;
                    } else if (tR == 1 && yb == 0) {
                        ny = 1;
                    }
                }
                
                dp[i][nx][ny] += dp[i+1][px][py];
                dp[i][nx][ny] %= MOD;
            }}
        }}
    }

    return (dp[0][0][0] + dp[0][0][1] + dp[0][1][0] + dp[0][1][1]) % MOD;

}

int main(int argc, char **argv) {
    std::cin >> L >> R;

    digR = digit(R, 2);
    digL = digit(L, 2);

    msbR = digR.size() - 1;
    msbL = digL.size() - 1;
    assert(msbL <= msbR);

    int128_t ret = 0;

    rep (i, msbL, msbR) {
        ret += solve(i);
        ret %= MOD;
    }

    std::cout << ret << std::endl;

    return 0;
}

Measured memory_bytes: 384