Given are integers L and R. Find the number, modulo 10^9 + 7, of pairs of integers (x, y) (L \leq x \leq y \leq R) such that the remainder when y is divided by x is equal to y \mbox{ XOR } x.What is \mbox{ XOR }?

The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:

 - When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.
For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)


-----Constraints-----
 - 1 \leq L \leq R \leq 10^{18}

-----Input-----
Input is given from Standard Input in the following format:
L R

-----Output-----
Print the number of pairs of integers (x, y) (L \leq x \leq y \leq R) satisfying the condition, modulo 10^9 + 7.

-----Sample Input-----
2 3

-----Sample Output-----
3

Three pairs satisfy the condition: (2, 2), (2, 3), and (3, 3).

Difficulty: interview

Starter code:

Solutions:
MOD = 10**9 + 7
l, r = map(int, input().split())

def func(x, y):
	if y == 0:
		return 1
	dp = [[0 for _ in range(6)] for _ in range(61)]
	dp[60][0] = 1
	for i in range(59, -1, -1):
		if (y>>i) & 1 == 0 and (x>>i) & 1 == 0:
			dp[i][0] = dp[i+1][0]
			dp[i][1] = dp[i+1][1]
			dp[i][2] = dp[i+1][2]
			dp[i][3] = (dp[i+1][3]*2) % MOD
			dp[i][4] = dp[i+1][4]
			dp[i][5] = (dp[i+1][1] + dp[i+1][3] + dp[i+1][5]*3) % MOD
		elif (y>>i) & 1 == 1 and (x>>i) & 1 == 1:
			dp[i][0] = 0
			dp[i][1] = 0
			dp[i][2] = (dp[i+1][0] + dp[i+1][2]) % MOD
			dp[i][3] = (dp[i+1][1] + dp[i+1][3]) % MOD
			dp[i][4] = (dp[i+1][4]*2) % MOD
			dp[i][5] = (dp[i+1][4] + dp[i+1][5]*3) % MOD
		elif (y>>i) & 1 == 1 and (x>>i) & 1 == 0:
			dp[i][0] = 0
			dp[i][1] = (dp[i+1][0] + dp[i+1][1]) % MOD
			dp[i][2] = dp[i+1][2]
			dp[i][3] = (dp[i+1][2] + dp[i+1][3]*2) % MOD
			dp[i][4] = (dp[i+1][0] + dp[i+1][2] + dp[i+1][4]*2) % MOD
			dp[i][5] = (dp[i+1][1] + dp[i+1][3] + dp[i+1][4] + dp[i+1][5]*3) % MOD
		elif (y>>i) & 1 == 0 and (x>>i) & 1 == 1:
			dp[i][0] = 0
			dp[i][1] = 0
			dp[i][2] = 0
			dp[i][3] = (dp[i+1][1] + dp[i+1][3]) % MOD
			dp[i][4] = dp[i+1][4]
			dp[i][5] = (dp[i+1][5]*3) % MOD

	return (sum(dp[0]))%MOD

print(func(l, r))

from functools import lru_cache
import sys
sys.setrecursionlimit(1000000)
P = 10**9+7
@lru_cache(maxsize=None)
def subcalc(l, r):
    if l < 0 or r < 0:
        print("ERROR")
        print(("l, r =", l, r))
        print((1//0))
    if l > r: return 0
    if r == 0: return 1
    aa, bb = l.bit_length(), r.bit_length()
    if aa == bb:
        return subcalc(l-(1<<aa-1), r-(1<<bb-1))
    if (r & (r+1) == 0) and (l == 0):
        return pow(3, r.bit_length(), P)
    t = (subcalc(l, r-(1<<bb-1)) + subcalc(l, (1<<bb-1)-1) + subcalc(0, r-(1<<bb-1))) % P
    # print("subcalc", l, r, t)
    return t

@lru_cache(maxsize=None)
def calc(L, R):
    if L < 0 or R < 0:
        print("ERROR")
        print(("l, r =", l, r))
        print((1//0))
    if L > R: return 0
    a = L.bit_length()
    b = R.bit_length()
    if b > a:
        t = (calc(L, (1<<b-1)-1) + calc(1<<b-1, R)) % P
        # print("calc", L, R, t)
        return t
    
        
        
    a = 1 << L.bit_length() - 1 if L else 0
    t = subcalc(L-a, R-a)
    # print("calc", L, R, t)
    return t

L, R = list(map(int, input().split()))
print((calc(L, R)))


def f_coincidence(MOD=10 ** 9 + 7):
    # 参考: https://atcoder.jp/contests/abc138/submissions/7013926
    from itertools import product
    L, R = [int(i) for i in input().split()]

    dp = [[[[0 for s in range(2)] for k in range(2)]
           for j in range(2)] for i in range(61)]
    dp[60][0][0][0] = 1

    for i in range(59, -1, -1):
        lb = (L >> i) & 1  # 'b' はビット値であることを示す(以下も同じ)
        rb = (R >> i) & 1

        r2 = range(2)
        for j, k, s in product(r2, r2, r2):
            pre = dp[i + 1][j][k][s]
            # ビットごとに値を試す
            for xb, yb in product(r2, r2):
                # editorial の通り、このビットの組は元の条件を満たさない
                if xb == 1 and yb == 0:
                    continue
                # editorial の通り、これ以降は x <= y が満たされる

                nj, nk, ns = j, k, s
                # 今注目している桁でMSBが立つか？
                if s == 0 and xb != yb:
                    continue  # どちらかが立っていない
                if s == 0 and xb == 1 and yb == 1:
                    ns = 1  # ここで初めてMSBが立った

                # L <= x を満たすか？
                if j == 0 and xb == 0 and lb == 1:
                    # jが0のまま xb<lb となれば、L<=xになりようがない
                    # jが1なら、xbとlbがどうなっていようがL<=xである
                    continue
                if j == 0 and xb == 1 and lb == 0:
                    nj = 1  # この桁で L<=x が確定する

                # y <= R を満たすか？
                if k == 0 and yb == 1 and rb == 0:
                    continue  # L<=x の場合分けと同じこと
                if k == 0 and yb == 0 and rb == 1:
                    nk = 1

                # 反映
                dp[i][nj][nk][ns] += pre
                dp[i][nj][nk][ns] %= MOD

    ans = sum([dp[0][j][k][s] for j in range(2) for k in range(2)
               for s in range(2)]) % MOD
    return ans

print(f_coincidence())

from itertools import product

MOD = 10**9 + 7

L, R = list(map(int, input().split()))

binR = bin(R+1)[2:]
maxD = len(binR)
binL = bin(L-1)[2:].zfill(maxD)

dp = [[[[0]*(2) for k in range(2)] for j in range(2)] for i in range(maxD+1)]
dp[0][0][0][0] = 1
for d, (Ld, Rd) in enumerate(zip(binL, binR)):
    Ld, Rd = int(Ld), int(Rd)
    for isLleX, isYleR, isNum in product(list(range(2)), repeat=3):
        for x, y in [(0,0), (0,1), (1,1)]:
            if not isNum and (x, y) == (0, 1): continue
            if not isLleX and x < Ld: continue
            if not isYleR and y > Rd: continue
            isLleX2 = isLleX or x > Ld
            isYleR2 = isYleR or y < Rd
            isNum2 = isNum or y == 1
            dp[d+1][isLleX2][isYleR2][isNum2] += dp[d][isLleX][isYleR][isNum]
            dp[d+1][isLleX2][isYleR2][isNum2] %= MOD

print((dp[-1][1][1][1]))


L,R = map(int,input().split())

mod = 10**9+7

def f(L,R):
    if L>R : return 0
    R = bin(R)[2:]
    N = len(R)
    ret = f(L,int("0"+"1"*(N-1),2))
    L = bin(L)[2:]
    if len(L) != N : L = "1"+"0"*(N-1)
    for i in range(N):
        if R[i] == "0" : continue
        R2 = R[:i] + "0" + "?"*(N-i-1)
        if i==0: R2 = R
        for j in range(N):
            if L[j] == "1" and j!=0 : continue
            L2 = L[:j] + "1" + "?"*(N-j-1)
            if j==0 : L2 = L
            if L2[0] == "0" : break
            tmp = 1
            for r,l in zip(R2[1:],L2[1:]):
                if r=="0" and l=="1" : tmp *= 0 ; break
                if r=="?" and l=="?" : tmp = tmp*3%mod
                if r=="?" and l=="0" : tmp = tmp*2%mod
                if r=="1" and l=="?" : tmp = tmp*2%mod
            ret += tmp
            ret %= mod
    return ret

print(f(L,R))

L, R = list(map(int, input().split()))

"""
R ????????1??????
y 0001????0??????
     ^d   ^rd
x 0001???????1??
             ^ld
L ???????????0???
"""

ans = 0

for d in range(70):
  if d<len(bin(L))-3:
    LD = []
  elif d==len(bin(L))-3:
    LD = [i for i in range(-1,d) if i==-1 or (L>>i&1)==0]
  else:
    LD = [d]
  if d<len(bin(R))-3:
    RD = [d]
  elif d==len(bin(R))-3:
    RD = [i for i in range(-1,d) if i==-1 or (R>>i&1)==1]
  else:
    RD = []
  for ld in LD:
    for rd in RD:
      a = 1
      for i in range(d):
        # i<ld:  x==0 or 1
        # i==ld: x==1
        # i>ld:  x==L
        # i<rd:  y==0 or 1
        # i==rd: y==0
        # i>rd:  y==R
        # y>=x
        if i<ld and i<rd:
          a *= 3
        if i<ld and i==rd:
          a *= 1
        if i<ld and i>rd:
          a *= (R>>i&1)+1
        if i==ld and i<rd:
          a *= 1
        if i==ld and i==rd:
          a *= 0
        if i==ld and i>rd:
          a *= (R>>i&1)
        if i>ld and i<rd:
          a *= 2-(L>>i&1)
        if i>ld and i==rd:
          if (L>>i&1)==0:
            a *= 1
          else:
            a *= 0
        if i>ld and i>rd:
          if (L>>i&1)==(R>>i&1):
            a *= 1
          if (L>>i&1)==0 and (R>>i&1)==1:
            a *= 1
          if (L>>i&1)==1 and (R>>i&1)==0:
            a *= 0
      ans += a
print(ans%(10**9+7))


MOD = 10**9 + 7

L, R = [int(item) for item in input().split()]
L_blen = L.bit_length()
R_blen = R.bit_length()

# dp[y loose/tight][x loose/tight][index]
dp = [[[0] * (R_blen+1) for _ in range(2)] for _ in range(2)]

for i in range(R_blen + 1):
    L_bit = L & (1 << R_blen - i)
    R_bit = R & (1 << R_blen - i)

    # Form R's MSB to L's LSB can be the initial bit  
    curbit_idx = R_blen - i + 1
    if curbit_idx <= R_blen and curbit_idx >= L_blen:
        dp[R_blen == curbit_idx][L_blen == curbit_idx][i] += 1

    # R=0, L=0
    if not R_bit and not L_bit:
        # y=1, x=1
        dp[0][0][i] += dp[0][0][i-1] 
        dp[0][0][i] += dp[0][1][i-1] 
        # y=0, x=0
        dp[1][1][i] += dp[1][1][i-1] 
        dp[1][0][i] += dp[1][0][i-1] 
        dp[0][0][i] += dp[0][0][i-1] 
        dp[0][1][i] += dp[0][1][i-1] 
        # y=1, x=0
        dp[0][1][i] += dp[0][1][i-1] 
        dp[0][0][i] += dp[0][0][i-1] 

    # R=1, L=0
    if R_bit and not L_bit:
        # y=1, x=1
        dp[0][0][i] += dp[0][0][i-1] 
        dp[1][0][i] += dp[1][0][i-1] 
        dp[0][0][i] += dp[0][1][i-1] 
        dp[1][0][i] += dp[1][1][i-1] 
        # y=0, x=0
        dp[0][0][i] += dp[0][0][i-1] 
        dp[0][0][i] += dp[1][0][i-1] 
        dp[0][1][i] += dp[0][1][i-1] 
        dp[0][1][i] += dp[1][1][i-1] 
        # y=1, x=0
        dp[0][0][i] += dp[0][0][i-1] 
        dp[1][0][i] += dp[1][0][i-1] 
        dp[0][1][i] += dp[0][1][i-1] 
        dp[1][1][i] += dp[1][1][i-1] 

    # R=0, L=1
    if not R_bit and L_bit:
        # y=1, x=1
        dp[0][0][i] += dp[0][0][i-1] 
        dp[0][1][i] += dp[0][1][i-1] 
        # y=0, x=0
        dp[0][0][i] += dp[0][0][i-1] 
        dp[1][0][i] += dp[1][0][i-1] 
        # y=1, x=0
        dp[0][0][i] += dp[0][0][i-1]

    # R=1, L=1
    if R_bit and L_bit:
        # y=1, x=1
        dp[0][0][i] += dp[0][0][i-1] 
        dp[1][0][i] += dp[1][0][i-1] 
        dp[0][1][i] += dp[0][1][i-1] 
        dp[1][1][i] += dp[1][1][i-1] 
        # y=0, x=0
        dp[0][0][i] += dp[1][0][i-1] 
        dp[0][0][i] += dp[0][0][i-1] 
        # y=1, x=0
        dp[1][0][i] += dp[1][0][i-1] 
        dp[0][0][i] += dp[0][0][i-1] 

    # Take MOD
    for i in range(2):
        for j in range(2):
            dp[i][j][i] %= MOD

ans = 0
for i in range(2):
    for j in range(2):
        ans += dp[i][j][-1]
        ans %= MOD
print(ans)

import os
import os
import sys
from collections import defaultdict

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7

L, R = list(map(int, sys.stdin.readline().split()))


def test(L, R):
    ans = 0
    cnt = defaultdict(int)
    for x in range(L, R + 1):
        for y in range(x, R + 1):
            if y % x == y ^ x:
                cnt[x + y % x] += 1
                ans += 1
    return ans


def solve(L, R):
    ret = L == 1
    for msb in range(R.bit_length()):
        r = min(R, (1 << msb + 1) - 1)
        l = max(L, (1 << msb))
        if l > r:
            continue
        # print(bin(r), bin(l))
        # dp[d][n][rより下を選んだ][lより上を選んだ]
        dp = np.zeros((r.bit_length(), 2, 2), dtype=int)
        for d in reversed(list(range(r.bit_length() - 1))):
            dp[-1][0][0] = 1
            if r >> d & 1:
                if l >> d & 1:
                    # r == 1, l == 1
                    # y1, x1
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][0] += dp[d + 1][1][0]
                    dp[d][0][1] += dp[d + 1][0][1]
                    dp[d][0][0] += dp[d + 1][0][0]
                    # y1, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][0][1] += dp[d + 1][0][1]
                    # y0, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][1] += dp[d + 1][0][1]
                else:
                    # r == 1, l == 0
                    # y1, x1
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][1] += dp[d + 1][1][0]
                    dp[d][0][1] += dp[d + 1][0][1]
                    dp[d][0][1] += dp[d + 1][0][0]
                    # y1, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][0] += dp[d + 1][1][0]
                    dp[d][0][1] += dp[d + 1][0][1]
                    dp[d][0][0] += dp[d + 1][0][0]
                    # y0, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][0] += dp[d + 1][1][0]
                    dp[d][1][1] += dp[d + 1][0][1]
                    dp[d][1][0] += dp[d + 1][0][0]
            else:
                if l >> d & 1:
                    # r == 0, l == 1
                    # y1, x1
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][0] += dp[d + 1][1][0]
                    # y1, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    # y0, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][0][1] += dp[d + 1][0][1]
                else:
                    # r == 0, l == 0
                    # y1, x1
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][1] += dp[d + 1][1][0]
                    # y1, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][0] += dp[d + 1][1][0]
                    # y0, x0
                    dp[d][1][1] += dp[d + 1][1][1]
                    dp[d][1][0] += dp[d + 1][1][0]
                    dp[d][0][1] += dp[d + 1][0][1]
                    dp[d][0][0] += dp[d + 1][0][0]
            dp[d] %= MOD
        ret += dp[0].sum()
        ret %= MOD
    return int(ret)


print((solve(L, R)))
# for l in range(1, R + 1):
#     for r in range(l, R + 1):
#         t1, t2 = solve(l, r), test(l, r)
#         if t1 != t2:
#             print(bin(l), bin(r), l, r, t1, t2)


L,R=map(int,input().split())
mod=10**9+7

DP_ini=[[[0 for i in range(2)] for j in range(2)] for k in range(64)]

import copy
ANS=0

for begin in range(64):
    DP=copy.deepcopy(DP_ini)

    if L<(1<<(begin+1)) and (1<<begin)<=R:

        if not(1<<begin <= L <  1<<(begin+1)) and not(1<<begin <= R <  1<<(begin+1)):
            DP[begin][0][0]=1

        elif 1<<begin <= L <  1<<(begin+1) and not(1<<begin <= R <  1<<(begin+1)):
            DP[begin][1][0]=1

        elif not(1<<begin <= L <  1<<(begin+1)) and 1<<begin <= R <  1<<(begin+1):
            DP[begin][0][1]=1

        else:
            DP[begin][1][1]=1

    for keta in range(begin-1,-1,-1):

        if L & (1<<keta)==0 and R & (1<<keta)==0:
            DP[keta][0][0]=DP[keta][0][0]+DP[keta+1][0][0]*3+DP[keta+1][0][1]*0+DP[keta+1][1][0]*1+DP[keta+1][1][1]*0
            DP[keta][0][1]=DP[keta][0][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*1+DP[keta+1][1][0]*0+DP[keta+1][1][1]*0
            DP[keta][1][0]=DP[keta][1][0]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*2+DP[keta+1][1][1]*0
            DP[keta][1][1]=DP[keta][1][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*0+DP[keta+1][1][1]*1

        elif L & (1<<keta)!=0 and R & (1<<keta)==0:
            DP[keta][0][0]=DP[keta][0][0]+DP[keta+1][0][0]*3+DP[keta+1][0][1]*0+DP[keta+1][1][0]*0+DP[keta+1][1][1]*0
            DP[keta][0][1]=DP[keta][0][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*1+DP[keta+1][1][0]*0+DP[keta+1][1][1]*0
            DP[keta][1][0]=DP[keta][1][0]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*1+DP[keta+1][1][1]*0
            DP[keta][1][1]=DP[keta][1][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*0+DP[keta+1][1][1]*0

        elif L & (1<<keta)==0 and R & (1<<keta)!=0:
            DP[keta][0][0]=DP[keta][0][0]+DP[keta+1][0][0]*3+DP[keta+1][0][1]*1+DP[keta+1][1][0]*1+DP[keta+1][1][1]*0
            DP[keta][0][1]=DP[keta][0][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*2+DP[keta+1][1][0]*0+DP[keta+1][1][1]*1
            DP[keta][1][0]=DP[keta][1][0]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*2+DP[keta+1][1][1]*1
            DP[keta][1][1]=DP[keta][1][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*0+DP[keta+1][1][1]*1
        else:
            DP[keta][0][0]=DP[keta][0][0]+DP[keta+1][0][0]*3+DP[keta+1][0][1]*1+DP[keta+1][1][0]*0+DP[keta+1][1][1]*0
            DP[keta][0][1]=DP[keta][0][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*2+DP[keta+1][1][0]*0+DP[keta+1][1][1]*0
            DP[keta][1][0]=DP[keta][1][0]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*1+DP[keta+1][1][1]*0
            DP[keta][1][1]=DP[keta][1][1]+DP[keta+1][0][0]*0+DP[keta+1][0][1]*0+DP[keta+1][1][0]*0+DP[keta+1][1][1]*1

    #print(begin,DP[0])
    ANS+=sum(DP[0][0])+sum(DP[0][1])

print(ANS%mod)

from functools import lru_cache
import sys
sys.setrecursionlimit(1000000)
P = 10**9+7
@lru_cache(maxsize=None)
def subcalc(l, r):
    if l < 0 or r < 0:
        print("ERROR")
        print("l, r =", l, r)
        print(1//0)
    if l > r: return 0
    if r == 0: return 1
    aa, bb = l.bit_length(), r.bit_length()
    if aa == bb:
        return subcalc(l-(1<<aa-1), r-(1<<bb-1))
    if (r & (r+1) == 0) and (l == 0):
        return pow(3, r.bit_length(), P)
    t = (subcalc(l, r-(1<<bb-1)) + subcalc(l, (1<<bb-1)-1) + subcalc(0, r-(1<<bb-1))) % P
    # print("subcalc", l, r, t)
    return t
 
@lru_cache(maxsize=None)
def calc(L, R):
    if L < 0 or R < 0:
        print("ERROR")
        print("l, r =", l, r)
        print(1//0)
    if L > R: return 0
    a = L.bit_length()
    b = R.bit_length()
    if b > a:
        t = (calc(L, (1<<b-1)-1) + calc(1<<b-1, R)) % P
        # print("calc", L, R, t)
        return t
    
        
        
    a = 1 << L.bit_length() - 1 if L else 0
    t = subcalc(L-a, R-a)
    # print("calc", L, R, t)
    return t
 
L, R = map(int, input().split())
print(calc(L, R))

import sys
import math

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline

def main():
    md = 10 ** 9 + 7
    l, r = list(map(int, input().split()))
    n = int(math.log2(r)) + 1
    # dp[i][t][f][g] i桁目まで見て最上位が決定済みか(t)、L<xが確定(f)、y<Rが確定
    dp = [[[[0] * 2 for _ in range(2)] for __ in range(2)] for ___ in range(n + 1)]
    dp[0][0][0][0] = 1
    ans = 0
    for i in range(n):
        lk = l >> (n - 1 - i) & 1
        rk = r >> (n - 1 - i) & 1
        for t in range(2):
            for f in range(2):
                for g in range(2):
                    pre = dp[i][t][f][g]
                    for x, y in [(0, 0), (0, 1), (1, 1)]:
                        nt, nf, ng = t, f, g
                        if t == 0 and (x, y) == (0, 1): continue
                        if f == 0 and lk > x: continue
                        if g == 0 and y > rk: continue
                        if (x, y) == (1, 1): nt = 1
                        if lk == 0 and x == 1: nf = 1
                        if y == 0 and rk == 1: ng = 1
                        if i == n - 1:
                            ans = (ans + pre) % md
                        else:
                            dp[i + 1][nt][nf][ng] = (dp[i + 1][nt][nf][ng] + pre) % md
    print(ans)

main()


L, R = list(map(int, input().split()))
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1]
r = '{:060b}'.format(R)[::-1]

memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]

def f(pos, flagX, flagY, flagZ):
    if pos == -1:
        return 1
    if memo[pos][flagX][flagY][flagZ] != -1:
        return memo[pos][flagX][flagY][flagZ]
    ret = 0
    # x 0, y 0
    if flagX or l[pos] == '0':
        ret += f(pos - 1, flagX, 1 if r[pos] == '1' else flagY, flagZ)
    # x 0, y 1
    if (flagX or l[pos] == '0') and (flagY or r[pos] == '1') and flagZ:
        ret += f(pos - 1, flagX, flagY, flagZ)
    # x 1, y 1
    if flagY or r[pos] == '1':
        ret += f(pos - 1, 1 if l[pos] == '0' else flagX, flagY, 1)
    ret %= MOD
    memo[pos][flagX][flagY][flagZ] = ret
    return ret

ans = f(59, 0, 0, 0)
print(ans)


# coding: utf-8
# Your code here!

import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline #文字列入力のときは注意

#n = int(input())
l,r = [int(i) for i in readline().split()]

def make_dp(init, size):
    res = "[{}]*{}".format(init,size[-1])
    for i in reversed(size[:-1]):
        res = "[{} for _ in [0]*{}]".format(res,i)
    return eval(res)


MOD = 10**9 + 7

R = bin(r)[2:]
L = bin(l)[2:]
L = "0"*(len(R)-len(L)) + L

dp = make_dp(0,(len(R)+1,2,2,2))
dp[0][0][0][0] = 1
for i, (r,l) in enumerate(zip(R,L)): #i桁目からi+1桁目に遷移
    ri = int(r)
    li = int(l)
    for is_less in range(2):
        for is_more in range(2):
            for is_nonzero in range(2):
                for dl in range(0 if is_more else li,2):
                    for dr in range(dl, 2 if is_less else ri+1): # d: i+1桁目の数字
                        dp[i+1][is_nonzero or dr != 0][is_more or li < dl][is_less or dr < ri] += dp[i][is_nonzero][is_more][is_less]*(dr==dl or is_nonzero)
                        dp[i+1][is_nonzero or dr != 0][is_more or li < dl][is_less or dr < ri] %= MOD

#print(dp[-1])
ans = 0
for i in range(2):
    for j in range(2):
        for k in range(2):
            ans += dp[-1][i][j][k]

print((ans%MOD))




import bisect
import collections
import itertools

def getint(): return int(input())
def getints(): return list(map(int, input().split()))
def getint2d(rows): return [getints() for _ in range(rows)]
def getgrid(rows): return [input() for _ in range(rows)]
def array1d(n, value): return [value for _ in range(n)]
def array2d(n, m, value): return [array1d(m, value) for _ in range(n)]

min_val,max_val=getints()

def get_key(pos, is_small, is_large, found):
    return ((pos * 2 + is_small) * 2 + is_large) * 2 + found

mod = 10**9 + 7
cache = [-1] * get_key(64,1,1,1)

def solve(pos, is_small, is_large, found):
    if pos < 0:
        return 1
    key = get_key(pos,is_small,is_large,found)
    res = cache[key]
    if res >= 0:
        return res

    res = 0
    for x in [0,1]:
        for y in [0,1]:
            if x == 1 and y == 0: continue
            if not is_small and x == 0 and (min_val >> pos & 1) == 1:
                continue
            if not is_large and y == 1 and (max_val >> pos & 1) == 0:
                continue
            if not found and x != y:
                continue
            new_is_small = True if x > (min_val >> pos & 1) else is_small
            new_is_large = True if y < (max_val >> pos & 1) else is_large
            new_found    = True if x == y and x == 1 else found
            res += solve(pos-1, new_is_small, new_is_large, new_found)

    res = res % mod
    cache[key] = res
    return res

print(solve(63, False, False, False))

L,R = map(int,input().split())

mod = 10**9+7
m = 64 +1
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
    fac[i] = fac[i-1]*i%mod
    ninv[i] = (-(mod//i)*ninv[mod%i])%mod
    finv[i] = finv[i-1]*ninv[i]%mod

def comb(n,k):
    return (fac[n]*finv[k]%mod)*finv[n-k]%mod

def f(L,R):
    if L>R : return 0
    R = bin(R)[2:]
    N = len(R)
    ret = f(L,int("0"+"1"*(N-1),2))
    L = bin(L)[2:]
    if len(L) != N : L = "1"+"0"*(N-1)
    for i in range(N):
        if R[i] == "0" : continue
        R2 = R[:i] + "0" + "?"*(N-i-1)
        if i==0: R2 = R
        for j in range(N):
            if L[j] == "1" and j!=0 : continue
            L2 = L[:j] + "1" + "?"*(N-j-1)
            if j==0 : L2 = L
            if L2[0] == "0" : break
            tmp = 1
            for r,l in zip(R2[1:],L2[1:]):
                if r=="0" and l=="1" : tmp *= 0
                if r=="?" and l=="?" : tmp *= 3
                if r=="?" and l=="0" : tmp *= 2
                if r=="1" and l=="?" : tmp *= 2
                tmp %= mod
            ret += tmp
            ret %= mod
    return ret%mod

print(f(L,R))

L,R = map(int,input().split())

mod = 10**9+7
m = 64 +1
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
    fac[i] = fac[i-1]*i%mod
    ninv[i] = (-(mod//i)*ninv[mod%i])%mod
    finv[i] = finv[i-1]*ninv[i]%mod

def comb(n,k):
    return (fac[n]*finv[k]%mod)*finv[n-k]%mod

def f(N):
    if N==0:return 0
    S = bin(N)[2:]
    L = len(S)
    ret = pow(2,S.count("1")-1,mod)
    for i in range(L):
        if S[i] == "0" : continue
        c = S[:i].count("1")
        j = max(0,L-i-1)
        for k in range(j+1):
            if c+k == 0 : continue
            ret += pow(2,c+k-1,mod)*comb(j,k)
            ret %= mod
    return ret

def g(R,L):
    if L==0 : return 0
    Nr = len(bin(R))-2
    Nl = len(bin(L))-2
    if Nr!=Nl :
        R = int("1"*Nl,2)
        Nr = Nl
    ret = f(int("0"+"1"*(Nr-1),2))
    
    R = bin(R)[2:]
    L = bin(L)[2:]
    for i in range(Nr):
        if R[i] == "0": continue
        if i==0 : R2 = R
        else: R2 = R[:i] + "0" + "?"*(Nr-i-1)
        for j in range(Nl):
            if L[j] == "0" : continue
            if j==0 : L2 = L
            else: L2 = L[:j] + "0" + "?"*(Nl-j-1)
            tmp = 1
            for r,l in zip(R2,L2):
                if r==l=="?" : tmp *= 3
                if r=="?" and l=="0" : tmp *= 2
                if r=="1" and l=="?" : tmp *= 2
                if r=="0" and l=="1" : tmp *= 0
                tmp %= mod
            ret += tmp
    return ret

print((f(R)-g(R,L-1))%mod)

from itertools import product
L, R = list(map(int, input().split()))
MOD = 10**9 + 7

dp = [[[0, 0] for _ in range(2)] for _ in range(2)]
pp = [[[0, 0] for _ in range(2)] for _ in range(2)]
dp[0][0][0] = 1
for d in range(60, -1, -1):
    pp, dp = dp, pp
    dp = [[[0, 0] for _ in range(2)] for _ in range(2)]
    lb = L>>d & 1
    rb = R>>d & 1
    if d == 1:
        pass
    ans = 0
    for lrs in product((0,1), repeat=3):
        l, r, s = lrs
        for xy in product((0,1), repeat=2):
            nl, nr, ns = l, r, s
            x, y = xy
            if x and not y:
                continue
            if not s and x != y:
                continue
            if x and y:
                ns = 1
            if not l and not x and lb:
                continue
            if x and not lb:
                nl = 1
            if not r and y and not rb:
                continue
            if not y and rb:
                nr = 1
            dp[nl][nr][ns] += pp[l][r][s]
            dp[nl][nr][ns] %= MOD

print((sum(dp[l][r][s] for l in (0,1) for r in (0,1) for s in (0,1)) % MOD))


L, R = map(int, input().split())
MOD = 10**9 + 7

*BL, = map(int, bin(L)[2:])
*BR, = map(int, bin(R)[2:])

a = len(BL)
b = len(BR)
BL = [0]*(len(BR) - len(BL)) + BL

BL.reverse()
BR.reverse()

memo = [[[-1]*2 for i in range(2)] for j in range(70)]
def dfs(i, p, q):
    if memo[i][p][q] != -1:
        return memo[i][p][q]
    if i == -1:
        memo[i][p][q] = 1
        return 1
    r = 0
    if p == q == 0:
        if BL[i] == 1 and BR[i] == 0:
            memo[i][0][0] = 0
            return 0
        if BL[i] == 1 or BR[i] == 0:
            r = dfs(i-1, 0, 0)
        else:
            r = (dfs(i-1, 0, 1) + dfs(i-1, 1, 0) + dfs(i-1, 0, 0)) % MOD
    elif p == 0:
        if BL[i] == 1:
            r = dfs(i-1, 0, 1)
        else:
            r = (2*dfs(i-1, 0, 1) + dfs(i-1, 1, 1)) % MOD
    elif q == 0:
        if BR[i] == 0:
            r = dfs(i-1, 1, 0)
        else:
            r = (2*dfs(i-1, 1, 0) + dfs(i-1, 1, 1)) % MOD
    else:
        r = 3 * dfs(i-1, 1, 1)
    memo[i][p][q] = r
    return r
ans = 0
for l in range(a-1, b):
    ans += dfs(l-1, +(not a-1 == l), +(not b-1 == l))
print(ans % MOD)

L, R = map(int, input().split())
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1]
r = '{:060b}'.format(R)[::-1]
 
memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]
 
def f(pos, flagX, flagY, flagZ):
    if pos == -1:
        return 1
    if memo[pos][flagX][flagY][flagZ] != -1:
        return memo[pos][flagX][flagY][flagZ]
    ret = 0
    # x 0 y 0
    if l[pos] == '0' or flagX:
      ret += f(pos - 1, flagX, 1 if flagY or r[pos] == '1' else 0, flagZ)
    # x 0 y 1
    if (l[pos] == '0' or flagX) and (r[pos] == '1' or flagY) and flagZ:
      ret += f(pos - 1, flagX, flagY, flagZ)
    # x 1 y 1
    if r[pos] == '1' or flagY:
      ret += f(pos - 1, 1 if l[pos] == '0' or flagX else 0, flagY, 1)
    ret %= MOD
    memo[pos][flagX][flagY][flagZ] = ret
    return ret
 
ans = f(59, 0, 0, 0)
print(ans)


LARGE = 10 ** 9 + 7

# flag_x : left < x
# flag_y : y < right
# flag_z : msb


def f(pos, flag_x, flag_y, flag_z, memo, left, right):
    if pos == -1:
        return 1
    if memo[pos][flag_x][flag_y][flag_z] != -1:
        return memo[pos][flag_x][flag_y][flag_z]
    ret = 0
    # x 0, y 0
    if flag_x or left[pos] == '0':
        ret += f(pos - 1, flag_x, 1 if right[pos] == '1' else flag_y, flag_z, memo, left, right)
    # x 0, y 1
    if (flag_x or left[pos] == '0') and (flag_y or right[pos] == '1') and flag_z:
        ret += f(pos - 1, flag_x, flag_y, flag_z, memo, left, right)
    # x 1, y 1
    if flag_y or right[pos] == '1':
        ret += f(pos - 1, 1 if left[pos] == '0' else flag_x, flag_y, 1, memo, left, right)
    ret %= LARGE
    memo[pos][flag_x][flag_y][flag_z] = ret
    return ret


def solve_greed_f(L, R):

    res_g = 0

    for i in range(L, R + 1):
        for j in range(i, R + 1):
            if j % i == j ^ i:
                res_g += 1

    return res_g


def main():

    ll, rr = list(map(int, input().split()))

    left = '{:060b}'.format(ll)[::-1]
    right = '{:060b}'.format(rr)[::-1]

    memo = [[[[-1 for m in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]

    res = f(59, 0, 0, 0, memo, left, right)

    print(res)


def __starting_point():
    main()

__starting_point()

from functools import lru_cache
P = 10**9+7
@lru_cache(maxsize=None)
def subcalc(l, r):
    if l > r: return 0
    if r == 0: return 1
    aa, bb = l.bit_length(), r.bit_length()
    if aa == bb:
        return subcalc(l-(1<<aa-1), r-(1<<bb-1))
    if (r & (r+1) == 0) and (l == 0):
        return pow(3, r.bit_length(), P)
    return (subcalc(l, r-(1<<bb-1)) + subcalc(l, (1<<bb-1)-1) + subcalc(0, r-(1<<bb-1))) % P

@lru_cache(maxsize=None)
def calc(L, R):
    if L > R: return 0
    a = L.bit_length()
    b = R.bit_length()
    if b > a:
        return (calc(L, (1<<b-1)-1) + calc(1<<b-1, R)) % P
    a = 1 << L.bit_length() - 1 if L else 0
    return subcalc(L-a, R-a)

L, R = list(map(int, input().split()))
print((calc(L, R)))


l, r = input().split()
l = int(l)
r = int(r)

dp = [[[-1 for k in range(2)] for j in range(2)] for i in range(64)]

def bbin(num):
    res = []
    while num:
        res.append(num % 2)
        num //= 2

    return res

numr = bbin(r)
numl = bbin(l)
while len(numl) < len(numr):
    numl.append(0)

def rec(pos, brr, brl):
    nonlocal numl, numr, dp
    if pos < 0:
        return 1

    if dp[pos][brr][brl] != -1:
        return dp[pos][brr][brl]

    res = 0
    if brr:
        if brl:
            res = 3 * rec(pos - 1, brr, brl)
        else:
            if numl[pos] == 1:
                res = rec(pos - 1, brr, brl)
            else:
                res += (2 * rec(pos - 1, brr, 0))
                res += rec(pos - 1, brr, 1)
    else:
        if numr[pos] == 1:
            if brl:
                res += (2 * rec(pos - 1, 0, brl))
                res += rec(pos - 1, 1, brl)
            else:
                if numl[pos] == 1:
                    res += rec(pos - 1, 0, brl)
                else:
                    res += rec(pos - 1, 0, 0)
                    res += rec(pos - 1, 0, 1)
                    res += rec(pos - 1, 1, 0)
        else:
            if brl:
                res += rec(pos - 1, 0, brl)
            elif numl[pos] == 0:
                res += rec(pos - 1, 0, 0)

    dp[pos][brr][brl] = res % (10**9 + 7)
    return dp[pos][brr][brl]

c = 0
for i in range(len(numl) - 1, -1, -1):
    if numl[i] == 1:
        c += rec(i - 1, 1 if i < len(numl) - 1 else 0, 0)
        break
    else:
        c += rec(i - 1, 1 if i < len(numl) - 1 else 0, 1)

print(c % (10**9 + 7))

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

from functools import lru_cache

MOD = 10 ** 9 + 7

"""
桁数が異なると矛盾
したがって商が1であることが必要
すると、xがyのsubsetであることが必要
一番上の桁を含むsubsetがx
"""

@lru_cache()
def F_naive(L,R):
    # 
    ret = 0
    ret += F((L+1)//2,(R+1)//2) # 2x,2y
    answer = 0
    for x in range(L,R+1):
        for y in range(x,R+1):
            if x.bit_length() == y.bit_length() and (x^y)+x == y:
                answer += 1
    return answer

@lru_cache()
def F(L,R):
    # x subset y かつ 2x > y
    if L < 0:
        L = 0
    if R < L:
        return 0
    if R == 0:
        return 0
    ret = 0
    # 下一桁が0,0ととる場合
    ret += F((L+1)//2, R//2)
    # 下一桁が0,1ととる場合
    # 2(2x) > (2y+1) iff 2x > y
    ret += F((L+1)//2,(R-1)//2)
    # 下一桁が1,0ととる場合
    # これはsubsetにならない

    # 下一桁が1,1ととる場合
    # 2(2x+1) > 2y+1 iff 2x >= y
    ret += G(L//2,(R-1)//2)
    return ret

@lru_cache()
def G(L,R):
    # x subset y かつ 2x >= y
    if L < 0:
        L = 0
    if R < L:
        return 0
    if R == 0:
        return 1
    ret = 0
    # 下一桁が0,0ととる場合
    ret += G((L+1)//2, R//2)
    # 下一桁が0,1ととる場合
    # 2(2x) >= (2y+1) iff 2x > y
    ret += F((L+1)//2,(R-1)//2)
    # 下一桁が1,0ととる場合
    # これはsubsetにならない

    # 下一桁が1,1ととる場合
    # 2(2x+1) >= 2y+1 iff 2x >= y
    ret += G(L//2,(R-1)//2)
    return ret

L,R = map(int,input().split())
answer = F(L,R) % MOD
print(answer)

L,R = map(int,input().split())

mod = 10**9+7

def f(L,R):
    if L>R : return 0
    R = bin(R)[2:]
    N = len(R)
    ret = f(L,int("0"+"1"*(N-1),2))
    L = bin(L)[2:]
    if len(L) != N : L = "1"+"0"*(N-1)
    for i in range(N):
        if R[i] == "0" : continue
        R2 = R[:i] + "0" + "?"*(N-i-1)
        if i==0: R2 = R
        for j in range(N):
            if j==0 : L2 = L
            elif L[j] == "1" : continue
            else : L2 = L[:j] + "1" + "?"*(N-j-1)

            tmp = 1
            for r,l in zip(R2,L2):
                if r=="0" and l=="1" : tmp *= 0 ; break
                elif r=="?" and l=="?" : tmp = tmp*3%mod
                elif r=="?" and l=="0" : tmp = tmp*2%mod
                elif r=="1" and l=="?" : tmp = tmp*2%mod
            ret += tmp
            ret %= mod
    return ret

print(f(L,R))

L, R = list(map(int, input().split()))
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1]
r = '{:060b}'.format(R)[::-1]

memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]

def f(pos, flagX, flagY, flagZ):
    if pos == -1:
        return 1
    if memo[pos][flagX][flagY][flagZ] != -1:
        return memo[pos][flagX][flagY][flagZ]
    ret = 0
    # x 0, y 0
    if flagX or l[pos] == '0':
        ret += f(pos - 1, flagX, 1 if r[pos] == '1' else flagY, flagZ)
    # x 0, y 1
    if (flagX or l[pos] == '0') and (flagY or r[pos] == '1') and flagZ:
        ret += f(pos - 1, flagX, flagY, flagZ)
    # x 1, y 1
    if flagY or r[pos] == '1':
        ret += f(pos - 1, 1 if l[pos] == '0' else flagX, flagY, 1)
    ret %= MOD
    memo[pos][flagX][flagY][flagZ] = ret
    return ret

ans = f(59, 0, 0, 0)
print(ans)


L, R = list(map(int, input().split()))
ans = 0
mod = 10 ** 9 + 7
for d in range(62):  # 最上位 bit
    # dp[n] := n 桁目まで見た時に条件を満たすものが何個あるか
    # dp_small[n] := n 桁目まで見た時に、l と x が n 桁目まで一致していて条件を満たすものが何個あるか
    l = max(1<<d, L)
    r = min((2<<d)-1, R)
    if l > r:
        continue
    dp_small = [0] * (d+2)
    dp_ok = [0] * (d+2)
    dp_large = [0] * (d+2)
    dp_small_large = [0] * (d+2)
    dp_small_large[0] = 1
    for n in range(1, d+2):
        i = d-n+1
        dp_ok[n] = dp_ok[n-1] * 3 \
                 + (dp_small[n-1] if l>>i&1==0 else 0) \
                 + (dp_large[n-1] if r>>i&1 else 0)
        dp_small[n] = dp_small[n-1] * (1 if l>>i&1 else 2) \
                    + (dp_small_large[n-1] if l>>i&1 < r>>i&1 else 0)
        dp_large[n] = dp_large[n-1] * (2 if r>>i&1 else 1) \
                    + (dp_small_large[n-1] if l>>i&1 < r>>i&1 else 0)
        dp_small_large[n] = dp_small_large[n-1] if l>>i&1 <= r>>i&1 else 0
    a = dp_ok[d+1] + dp_large[d+1] + dp_small[d+1] + dp_small_large[d+1]
    ans += a
    # print(f"d={d},a={a},l={l},r={r}")
    # print(f"dp_ok={dp_ok}")
    # print(f"dp_small={dp_small}")
    # print(f"dp_large={dp_large}")
    # print(f"dp_small_large={dp_small_large}")
    # print()
print((ans % mod))


L,R = map(int,input().split())

mod = 10**9+7

def f(L,R):
    if L>R : return 0
    R = bin(R)[2:]
    N = len(R)
    ret = f(L,int("0"+"1"*(N-1),2))
    L = bin(L)[2:]
    if len(L) != N : L = "1"+"0"*(N-1)
    for i in range(N):
        if R[i] == "0" : continue
        R2 = R[:i] + "0" + "?"*(N-i-1)
        if i==0: R2 = R
        for j in range(N):
            if L[j] == "1" and j!=0 : continue
            L2 = L[:j] + "1" + "?"*(N-j-1)
            if j==0 : L2 = L
            tmp = 1
            for r,l in zip(R2,L2):
                if r=="0" and l=="1" : tmp *= 0 ; break
                elif r=="?" and l=="?" : tmp = tmp*3%mod
                elif r=="?" and l=="0" : tmp = tmp*2%mod
                elif r=="1" and l=="?" : tmp = tmp*2%mod
            ret += tmp
            ret %= mod
    return ret

print(f(L,R))

l,r=map(int,input().split())
M=len(bin(r))-2
L=format(l,"b").zfill(M)
R=format(r,"b")
mod=10**9+7
dp=[[0 for l in range(70)] for i in range(5)]
if L[0]=="1":
  dp[2][0]=1
else:
  dp[3][0]=1
  dp[0][0]=1
for i in range(1,M):
  if L[i]=="1" and R[i]=="1":
    dp[1][i]=(dp[0][i-1]+dp[1][i-1])%mod
    dp[2][i]=(dp[2][i-1])%mod
    dp[3][i]=(2*dp[3][i-1])%mod
    dp[4][i]=(dp[3][i-1]+3*dp[4][i-1])%mod
  elif L[i]=="1" and R[i]=="0":
    dp[1][i]=dp[1][i-1]+dp[0][i-1]
    dp[3][i]=dp[3][i-1]
    dp[4][i]=(dp[4][i-1]*3)%mod
  elif L[i]=="0" and R[i]=="1":
    dp[0][i]=dp[0][i-1]
    dp[1][i]=(2*dp[1][i-1]+dp[2][i-1])%mod
    dp[2][i]=dp[2][i-1]
    dp[3][i]=(dp[2][i-1]+dp[3][i-1]*2)%mod
    dp[4][i]=(dp[0][i-1]+dp[1][i-1]+dp[3][i-1]+dp[4][i-1]*3)%mod
  else:
    dp[0][i]=dp[0][i-1]
    dp[1][i]=(dp[1][i-1]*2)%mod
    dp[2][i]=dp[2][i-1]
    dp[3][i]=(dp[3][i-1])%mod
    dp[4][i]=(dp[0][i-1]+dp[1][i-1]+dp[4][i-1]*3)%mod
ans=0
for i in range(5):
  ans+=dp[i][M-1]
  ans%=mod
print(ans)

L,R = map(int,input().split())

mod = 10**9+7
m = 64 +1
fac = [1]*m
ninv = [1]*m
finv = [1]*m
for i in range(2,m):
    fac[i] = fac[i-1]*i%mod
    ninv[i] = (-(mod//i)*ninv[mod%i])%mod
    finv[i] = finv[i-1]*ninv[i]%mod

def comb(n,k):
    return (fac[n]*finv[k]%mod)*finv[n-k]%mod

def f(L,R):
    if L>R : return 0
    R = bin(R)[2:]
    N = len(R)
    ret = f(L,int("0"+"1"*(N-1),2))
    L = bin(L)[2:]
    if len(L) != N : L = "1"+"0"*(N-1)
    for i in range(N):
        if R[i] == "0" : continue
        R2 = R[:i] + "0" + "?"*(N-i-1)
        if i==0: R2 = R
        for j in range(N):
            if L[j] == "1" and j!=0 : continue
            L2 = L[:j] + "1" + "?"*(N-j-1)
            if j==0 : L2 = L
            if L2[0] == "0" : break
            tmp = 1
            for r,l in zip(R2[1:],L2[1:]):
                if r=="0" and l=="1" : tmp *= 0
                if r=="?" and l=="?" : tmp *= 3
                if r=="?" and l=="0" : tmp *= 2
                if r=="1" and l=="?" : tmp *= 2
            ret += tmp
            ret %= mod
    return ret%mod

print(f(L,R))

m=10**9+7
l,r=list(map(int,input().split()))
dp=[[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)] for _ in range(61)]

dp[60][0][0][0]=1

for i in reversed(list(range(60))):
  lb=l>>i&1
  rb=r>>i&1
  for j in range(2):
    for k in range(2):
      for s in range(2):
        pre=dp[i+1][j][k][s]
        for x,y in [(0,0),(0,1),(1,1)]: # excpet for (1,0) (because of x<y)
          nj,nk,ns=j,k,s
          # s
          if (s==0 and x==0 and y==1): continue; # skip for not x==y==1
          if (s==0 and x&y): ns=1;
          # j
          if (j==0 and lb==1 and x==0): continue; # skip for x<l
          if (j==0 and lb==0 and x==1): nj=1;
          # k
          if (k==0 and rb==0 and y==1): continue; # skip for r<y
          if (k==0 and rb==1 and y==0): nk=1;           
            
          dp[i][nj][nk][ns]+=pre
          dp[i][nj][nk][ns]%=m    
                  
ans=0             
for j in range(2):
  for k in range(2):
    ans+=dp[0][j][k][1]
    ans%=m
print(ans)
                  


L, R = map(int, input().split())
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1]
r = '{:060b}'.format(R)[::-1]
 
memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]
 
def f(pos, flagX, flagY, flagZ):
    if pos == -1:
        return 1
    if memo[pos][flagX][flagY][flagZ] != -1:
        return memo[pos][flagX][flagY][flagZ]
    ret = 0
    # x 0, y 0
    if flagX or l[pos] == '0':
        ret += f(pos - 1, flagX, 1 if r[pos] == '1' else flagY, flagZ)
    # x 0, y 1
    if (flagX or l[pos] == '0') and (flagY or r[pos] == '1') and flagZ:
        ret += f(pos - 1, flagX, flagY, flagZ)
    # x 1, y 1
    if flagY or r[pos] == '1':
        ret += f(pos - 1, 1 if l[pos] == '0' else flagX, flagY, 1)
    ret %= MOD
    memo[pos][flagX][flagY][flagZ] = ret
    return ret
 
ans = f(59, 0, 0, 0)
print(ans)

MOD = 10**9 + 7
class mint:
    def __init__(self, i):
        self.i = i
    def __add__(self, m):
        t = self.i + (m.i if isinstance(m, mint) else m)
        if t > MOD:
            t -= MOD
        return mint(t)
    def __radd__(self, m):
        t = self.i + (m.i if isinstance(m, mint) else m)
        if t > MOD:
            t -= MOD
        return mint(t)
    def __mul__(self, m):
        return mint(self.i * (m.i if isinstance(m, mint) else m) % MOD)
    def __sub__(self, m):
        t = self.i - m.i
        if t < 0:
            t += MOD
        return mint(t)
    def __pow__(self, m):
        i = self.i
        res = 1
        while(m > 0):
            if m & 1:
                res = res * i % MOD 
            i = i * i % MOD
            m >>= 1
        return mint(res)
    def __truediv__(self, m):
        return mint(self.i * (m ** (MOD - 2)).i % MOD)
    def __repr__(self):
        return repr(self.i)

L, R = map(int, input().split())
dp = [[mint(0) for _ in range(4)] for _ in range(61)]

for d in range(60, 0, -1):
    l = L >> d - 1 & 1
    r = R >> d - 1 & 1
    
    if (L >> d - 1) == 0:
        if (R >> d - 1) > 1:
            dp[d-1][3] += 1
        elif (R >> d - 1) == 1:
            dp[d-1][2] += 1
    elif (L >> d - 1) == 1:
        if (R >> d - 1) > 1:
            dp[d-1][1] += 1
        else:
            dp[d-1][0] += 1

    # x bound, y bound
    if l == r:
        dp[d-1][0] += dp[d][0]
    elif l < r:
        dp[d-1][0] += dp[d][0]
        dp[d-1][1] += dp[d][0]
        dp[d-1][2] += dp[d][0]
    # x bound, y free
    if l == 0:
        dp[d-1][1] += dp[d][1] * 2
        dp[d-1][3] += dp[d][1]
    else:
        dp[d-1][1] += dp[d][1]
    # x free, y bound
    if r == 1:
        dp[d-1][2] += dp[d][2] * 2
        dp[d-1][3] += dp[d][2]
    else:
        dp[d-1][2] += dp[d][2]
    # x free, y free
    dp[d-1][3] += dp[d][3] * 3

print(sum(dp[0]))

L, R = list(map(int, input().split()))
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1]
r = '{:060b}'.format(R)[::-1]

memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]

def f(pos, flagX, flagY, flagZ):
    if pos == -1:
        return 1
    if memo[pos][flagX][flagY][flagZ] != -1:
        return memo[pos][flagX][flagY][flagZ]
    ret = 0
    # x 0, y 0
    if flagX or l[pos] == '0':
        ret += f(pos - 1, flagX, 1 if r[pos] == '1' else flagY, flagZ)
    # x 0, y 1
    if (flagX or l[pos] == '0') and (flagY or r[pos] == '1') and flagZ:
        ret += f(pos - 1, flagX, flagY, flagZ)
    # x 1, y 1
    if flagY or r[pos] == '1':
        ret += f(pos - 1, 1 if l[pos] == '0' else flagX, flagY, 1)
    ret %= MOD
    memo[pos][flagX][flagY][flagZ] = ret
    return ret

ans = f(59, 0, 0, 0)
print(ans)


def count(lb, rb):
    assert lb[0] == '1'
    assert rb[0] == '1'
    assert len(lb) == len(rb)
    dp = [1, 0, 0, 0]
    for lc, rc in zip(lb[1:], rb[1:]):
        ndp = [dp[0], 0, 0, 0]
        if rc == '0':
            ndp[1] += dp[1]
            if lc == '1':
                ndp[0] = 0
        else:
            ndp[1] += dp[1] * 2
            ndp[2] += dp[1]
            if lc == '0':
                ndp[1] += dp[0]
                ndp[3] += dp[0]
        if lc == '0':
            ndp[2] += dp[3]
            ndp[3] += dp[3] * 2
        else:
            ndp[3] += dp[3]
        ndp[2] += dp[2] * 3
        dp = ndp
    return sum(dp)


l, r = list(map(int, input().split()))
lb = bin(l)[2:]
rb = bin(r)[2:]
ld = len(lb)
rd = len(rb)
ans = 0
MOD = 10 ** 9 + 7
for d in range(ld, rd + 1):
    tlb = lb if d == ld else '1' + '0' * (d - 1)
    trb = rb if d == rd else '1' * d
    ans = (ans + count(tlb, trb)) % MOD
print(ans)


L, R = list(map(int, input().split()))

"""
R ????????1??????
y 0001????0??????
     ^d   ^rd
x 0001???????1??
             ^ld
L ???????????0???
"""

ans = 0

for d in range(70):
  if d<len(bin(L))-3:
    LD = []
  elif d==len(bin(L))-3:
    LD = [i for i in range(-1,d) if i==-1 or (L>>i&1)==0]
  else:
    LD = [d]
  if d<len(bin(R))-3:
    RD = [d]
  elif d==len(bin(R))-3:
    RD = [i for i in range(-1,d) if i==-1 or (R>>i&1)==1]
  else:
    RD = []
  for ld in LD:
    for rd in RD:
      a = 1
      for i in range(d):
        if i<ld:
          xc = [0, 1]
        elif i==ld:
          xc = [1]
        else:
          xc = [L>>i&1]
        if i<rd:
          yc = [0, 1]
        elif i==rd:
          yc = [0]
        else:
          yc = [R>>i&1]
        c = 0
        for x in xc:
          for y in yc:
            if y>=x:
              c += 1
        a *= c
      ans += a
print(ans%(10**9+7))


mod = 10 ** 9 + 7

memo = {}
def solve(L, R):
    if (L, R) in memo:
        return memo[(L, R)]

    if L > R:
        res = 0
    elif L == 1:
        res = 1 + solve(2, R)
    else:
        res = (
            solve(L // 2, (R - 1) // 2) +
            solve((L + 1) // 2, R // 2) +
            solve((L + 1) // 2, (R - 1) // 2)
        )

    res %= mod
    memo[(L, R)] = res
    return res

L, R = map(int, input().split())
print(solve(L, R) % mod)

L, R = list(map(int, input().split()))
MOD = 10 ** 9 + 7
l = '{:060b}'.format(L)[::-1] # 0左詰の二進数６０桁のstr　を逆向きにスライス
r = '{:060b}'.format(R)[::-1] # (桁数60 は　R<=10**18<2**60 より)

memo = [[[[-1 for l in range(2)] for k in range(2)] for j in range(2)] for i in range(60)]

# flagZは、既にx＝y＝1の位があったかチェックしている(MSB)
def f(pos, flagX, flagY, flagZ):
    if pos == -1:
        return 1
    if memo[pos][flagX][flagY][flagZ] != -1:
        return memo[pos][flagX][flagY][flagZ]
    ret = 0
    # x 0, y 0
    if flagX or l[pos] == '0':
        ret += f(pos - 1, flagX, 1 if r[pos] == '1' else flagY, flagZ)
    # x 0, y 1
    if (flagX or l[pos] == '0') and (flagY or r[pos] == '1') and flagZ:
        ret += f(pos - 1, flagX, flagY, flagZ)
    # x 1, y 1
    if flagY or r[pos] == '1':
        ret += f(pos - 1, 1 if l[pos] == '0' else flagX, flagY, 1)
    ret %= MOD
    memo[pos][flagX][flagY][flagZ] = ret
    return ret

ans = f(59, 0, 0, 0) #最大桁からスタート
print(ans)