A positive integer is called a 2-3-integer, if it is equal to 2x·3y for some non-negative integers x and y. In other words, these integers are such integers that only have 2 and 3 among their prime divisors. For example, integers 1, 6, 9, 16 and 108 — are 2-3 integers, while 5, 10, 21 and 120 are not.

Print the number of 2-3-integers on the given segment [l, r], i. e. the number of sich 2-3-integers t that l ≤ t ≤ r.

Input

The only line contains two integers l and r (1 ≤ l ≤ r ≤ 2·109).

Output

Print a single integer the number of 2-3-integers on the segment [l, r].

Examples

Input

1 10


Output

7


Input

100 200


Output

5


Input

1 2000000000


Output

326

Note

In the first example the 2-3-integers are 1, 2, 3, 4, 6, 8 and 9.

In the second example the 2-3-integers are 108, 128, 144, 162 and 192.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.lang.Math;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {

    private static DecimalFormat df = new DecimalFormat("0.00");   
    public static void main(String[] args) 
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1,in,out);
        out.close();
    }

    static class TaskA 
    {
        private long[][] dp=new long[2][40];
        public void solve(int tc, InputReader in, PrintWriter out) 
        {
            dp[0][0]=1;
            dp[1][0]=1;
            
            for(int i=1;i<35;i++)
            {
                dp[0][i]=dp[0][i-1]*2;
                dp[1][i]=dp[1][i-1]*3;
            }
            long l,r;
            l=in.nextLong();
            r=in.nextLong();
            
            int cnt=0;
            
            ///for(int i=0;i<10;i++) out.print(dp[0][i]+" ");
            
            for(int i=0;i<32;i++)
            {
                for(int j=0;j<32;j++)
                {
                    long temp=dp[0][i]*dp[1][j];
                    if(temp>=l && temp<=r) cnt++;
                }
            }
            out.println(cnt);
        }
        
        
    }


    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream){ 
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

    }
}
   			 	  	       	  	   						