215_E. Periodical Numbers
A non-empty string s is called binary, if it consists only of characters "0" and "1". Let's number the characters of binary string s from 1 to the string's length and let's denote the i-th character in string s as si.

Binary string s with length n is periodical, if there is an integer 1 ≤ k < n such that: 

  * k is a divisor of number n
  * for all 1 ≤ i ≤ n - k, the following condition fulfills: si = si + k



For example, binary strings "101010" and "11" are periodical and "10" and "10010" are not.

A positive integer x is periodical, if its binary representation (without leading zeroes) is a periodic string.

Your task is to calculate, how many periodic numbers are in the interval from l to r (both ends are included).

Input

The single input line contains two integers l and r (1 ≤ l ≤ r ≤ 1018). The numbers are separated by a space.

Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Output

Print a single integer, showing how many periodic numbers are in the interval from l to r (both ends are included).

Examples

Input

1 10


Output

3


Input

25 38


Output

2

Note

In the first sample periodic numbers are 3, 7 and 10.

In the second sample periodic numbers are 31 and 36.
```python
from itertools import combinations
from fractions import gcd

#Numeros primos hasta el 59
primos = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59]

#Para obtener la cadena binaria de x.
def ToBinary(x):
    if x == 0:
        return "0"
    if x == 1:
        return "1"
    if x % 2 == 0:
        return ToBinary(x>>1)+ "0"
    else:
        return ToBinary(x>>1)+ "1"

#Obtiene la cantidad de numeros periodicos con longitud de cadena binaria
#igual a "length".
def CountPeriodic(length):
    #Contiene los numeros primos que dividen a "length".
    p = [x for x in primos if length % x == 0]
    ans = 0
    for x in p:
        #"d" cantidad de repeticiones en las variaciones de "0" y "1", y "x" cantidad de subcadenas.
        d = length/x
        #Se agrega a la respuesta la cantidad de variaciones de "0" y "1" con "d-1" repeticiones
        #porque el primer elemento siempre es "1".
        ans += 2**(d-1)
    for x,y in combinations(p,2):
        #Se calcula el mcd de todos los primos 2 a 2.
        d = gcd(length/x, length/y)
        #Se elimina de la respuesta el total de variaciones con cantidad de repeticiones igual al
        #"mcd -1", mcd de dos primos diferentes dichas variaciones se contaron doble, es decir,
        #una vez por cada uno de los primos.
        ans -= 2**(d-1)
    for x,y,z in combinations(p,3):
        d = gcd(gcd(length/x, length/y), length/z)
        #Aplicando el principio de inclusion-exclusion, si en el paso anterior se sustrajo
        #el total de variaciones de "0" y "1" con cantidad de repeticiones asociadas al mismo mcd de tres primos distintos, significa que se quitaron
        #dos veces, luego se debe agregar a la respuesta la cardinalidad del conjunto de esas
        #variaciones (solo una vez).
        ans += 2**(d-1)
    return ans

#Chequea las variaciones para las cadenas binarias cuyos numeros son mayores o iguales
#que el de la cadena "l".
def L(l,x,d):
    ans = 0
    d = int(d)
    x = int(x)
    p = 1
    while True:
        #"q" es la posicion de "0" en el substring "l[p:d]".
        q = l[p:d].find('0')
        if q == -1:
            break
        #Se añade a la respuesta el total de variacines de "0" y "1" con "d" repeticiones, pero con todas las
        #posiciones fijadas desde la primera hasta la del "p"-esimo "0" encontrado en el substring.
        ans += 2**(d-(p+q)-1)
        p += q+1

    for k in range(1,x):
        #Si todos los digitos en el substring "l[0:d]" son mayores que los del siguente k substring, se debe
        #aumentar la respuesta en 1 porque es posible crear una cadena binaria de periodo "x" con "l[0:d]".         
        if l[0:d] > l[d*k:d*(k+1)]:
            return ans+1        
        elif l[0:d] == l[d*k:d*(k+1)]:
            continue
        else:
            #No es posible obtener una cadena binaria de periodo "x" con "l[0:d]". 
            return ans
    #Si el programa llega hasta aqui implica que todos los substring son iguales
    #por tanto la cadena binaria pertenece a un numero periodico entonces hay que
    #aumentar la respuesta en 1.
    return ans+1

def CountPeriodicL(l):
    length = len(l)
    p = [x for x in primos if length % x == 0]
    ans = 0
    for x in p:
        d = length/x
        ans += L(l,x,d)
    for x,y in combinations(p,2):
        d = gcd(length/x, length/y)        
        ans -= L(l,length/d,d)
    for x,y,z in combinations(p,3):
        d = gcd(gcd(length/x, length/y), length/z)
        ans += L(l,length/d,d)
    return ans


#Chequea las variaciones para las cadenas binarias cuyos numeros son menores o iguales
#que el de la cadena "r".
def R(r,x,d,eq=False):
    ans = 0
    d = int(d)
    x = int(x)
    p = 1
    while True:        
        q = r[p:d].find('1')
        if q == -1:
            break
        ans += 2**(d-(p+q)-1)
        p += q+1
    for k in range(1,x):
        if r[0:d] < r[d*k:d*(k+1)]:
            return ans+1
        elif r[0:d] == r[d*k:d*(k+1)]:
            continue
        else:
            return ans
    return ans+(1 if not eq else 0)

def CountPeriodicR(r,eq=False):
    length = len(r)
    p = [x for x in primos if length % x == 0]
    ans = 0
    for x in p:
        d = length/x
        ans += R(r,x,d,eq)
    for x,y in combinations(p,2):
        d = gcd(length/x, length/y)        
        ans -= R(r,length/d,d,eq)
    for x,y,z in combinations(p,3):
        d = gcd(gcd(length/x, length/y), length/z)
        ans += R(r,length/d,d,eq)
    return ans



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

l_binary = ToBinary(l)
r_binary = ToBinary(r)

ans = 0

#Chequea la cantidad de numeros periodicos cuya longitud de cadena binaria se encuentra en el
#interior del intervalo conformado por las longitudes de las cadenas binaras de los numeros del intervalo del
#ejercicio.
for i in range(len(l_binary)+1,len(r_binary)):   
    ans += CountPeriodic(i)

#Chequea la cantidad de numeros periodicos con longitud de cadenas binarias igual a la de los extremos
#del intervalo del ejercicio, en el caso del extremo izquierdo solo se calculan aquellos numeros mayores o
#iguales a "l", y en el caso del derecho los menores o iguales a "r".
if len(l_binary)==len(r_binary):
    ans += CountPeriodicR(r_binary)
    ans -= CountPeriodicR(l_binary,True)
else:
    ans += CountPeriodicL(l_binary)
    ans += CountPeriodicR(r_binary)


print(int(ans))
```