#include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
constexpr ll INF = (1LL << 30) - 1LL;
constexpr ll LINF = (1LL << 60) - 1LL;
constexpr double eps = 1e-9;
constexpr ll MOD = 1000000007LL;
template <typename T> bool chmin(T &a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
};
template <typename T> bool chmax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
};
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
    for (int i = 0; i < v.size(); i++) {
        os << v[i] << (i + 1 == v.size() ? "\n" : " ");
    }
    return os;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
    t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
    for (auto &e : t) {
        fill_v(e, v);
    }
};
template <ll mod> struct modint {
    ll val;
    inline ll extgcd(ll a, ll b, ll &x, ll &y) {
        if (a < b) {
            return extgcd(b, a, y, x);
        }
        if (b == 0) {
            x = 1, y = 0;
            return a;
        }
        ll d = extgcd(b, a % b, y, x);
        y -= a / b * x;
        return d;
    }
    inline ll minv(ll k) {
        ll x = 0, y = 0;
        extgcd(k, mod, x, y);
        if (x < 0) {
            x += mod;
        } else if (x == mod) {
            x = 0;
        }
        return x;
    }
    constexpr modint() : val(0) {}
    constexpr modint(ll x) { val = (x + mod) % mod; }
    modint inv() { return modint(minv(val)); }
    modint operator+(const modint &to) const { return modint(val + to.val); }
    modint operator-(const modint &to) const { return modint(val - to.val); }
    modint operator*(const modint &to) const { return modint(val * to.val); }
    modint operator/(const modint &to) const {
        return modint(val * minv(to.val));
    }
    template <class T> explicit operator T() { return T(val); }
    template <typename T> modint operator+(const T &to) const {
        return modint(val + to);
    }
    template <typename T> modint operator-(const T &to) const {
        return modint(val - to);
    }
    template <typename T> modint operator*(const T &to) const {
        return modint(val * to);
    }
    template <typename T> modint operator/(const T &to) const {
        return modint(val * minv(to));
    }
    modint &operator++() { return *this = modint(val + 1); }
    modint &operator--() { return *this = modint(val - 1); }
    template <typename T> modint &operator+=(const T &to) {
        return *this = *this + to;
    }
    template <typename T> modint &operator-=(const T &to) {
        return *this = *this - to;
    }
    template <typename T> modint &operator*=(const T &to) {
        return *this = *this * to;
    }
    template <typename T> modint &operator/=(const T &to) {
        return *this = *this / to;
    }
    bool operator==(const modint &to) const { return val == to.val; }
    bool operator!=(const modint &to) const { return val != to.val; }
    bool operator>(const modint &to) const { return val > to.val; }
    bool operator>=(const modint &to) const { return val >= to.val; }
    bool operator<(const modint &to) const { return val < to.val; }
    bool operator<=(const modint &to) const { return val <= to.val; }
};
using mint = modint<MOD>;
mint dp[64][2][2][2][2]; // i,l==x?,y==r?,x==y?,既にbitが立っているか
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll l, r;
    cin >> l >> r;
    dp[61][1][1][1][0] = 1;
    for (ll i = 60; i >= 0; i--) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                for (int m = 0; m < 2; m++) {
                    for (int o = 0; o < 2; o++) {
                        if (j == 1 && k == 0) {
                            continue;
                        }
                        int to = m;
                        if (m == 0 && j == 0 && k == 1) {
                            continue;
                        }
                        if (m == 0 && j > 0 && k > 0) {
                            to = 1;
                        }
                        int to2 = o;
                        if (j < k) {
                            to2 = 0;
                        }
                        dp[i][0][0][to2][to] += dp[i + 1][0][0][o][m];
                        if (((l >> i) & 1) == j) {
                            dp[i][1][0][to2][to] += dp[i + 1][1][0][o][m];
                        } else if (((l >> i) & 1) < j) {
                            dp[i][0][0][to2][to] += dp[i + 1][1][0][o][m];
                            if (((r >> i) & 1) >= k &&
                                (o == 0 || ((r >> i) & 1) >= j)) {
                                dp[i][0][1][to2][to] += dp[i + 1][1][1][o][m];
                            }
                        }
                        if (((r >> i) & 1) == k) {
                            dp[i][0][1][to2][to] += dp[i + 1][0][1][o][m];
                        } else if (((r >> i) & 1) > k) {
                            dp[i][0][0][to2][to] += dp[i + 1][0][1][o][m];
                            if (((l >> i) & 1) <= j &&
                                (o == 0 || ((l >> i) & 1) <= k)) {
                                dp[i][1][0][to2][to] += dp[i + 1][1][1][o][m];
                            }
                        }
                        if (((l >> i) & 1) == j && ((r >> i) & 1) == k) {
                            dp[i][1][1][to2][to] += dp[i + 1][1][1][o][m];
                        }
                    }
                }
            }
        }
    }
    mint res = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                res += dp[0][i][j][k][1];
            }
        }
    }
    cout << res.val << endl;
}


Measured memory_bytes: 256