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.math.BigInteger;
							import java.sql.Array;
						    import java.util.ArrayList;
							import java.util.Arrays;
							import java.util.Collection;
							import java.util.Collections;
							import java.util.Comparator;
							import java.util.HashMap;
							import java.util.InputMismatchException;
							import java.util.Iterator;
							import java.util.LinkedHashSet;
							import java.util.LinkedList;
							import java.util.List;
							import java.util.Map;
							import java.util.Map.Entry;	
							import java.util.PriorityQueue;
							import java.util.Queue;
							import java.util.Scanner;
							import java.util.Set;
							import java.util.Stack;
							import java.io.BufferedReader;
							import java.io.IOException;
							import java.io.InputStream;
							import java.io.InputStreamReader;
							import java.util.Scanner;
							import java.util.StringTokenizer;
							import java.util.TreeMap;
							import java.util.TreeSet;
							
							public class Main {
								
								
								
								static InputReader rd=new InputReader(System.in);
								public static void main(String[] args) {
									Scanner sc=new Scanner(System.in);
									
									
									
									
									
									
									
									long l=sc.nextLong();
									long r=sc.nextLong();
									
									
									
									solve(l, r, 1l);
									System.out.println(c);
									
									}
									
								
								static HashMap<Long,Integer> map=new HashMap<Long, Integer>();
								static int c=0;
								static void  solve(long l,long r,long n) {
										
									
									if(r<n) {return;}
									
									if(l<=n&&r>=n) {
										
										if(!map.containsKey(n)) {
										c++;
										//System.out.println(c);
									//	System.out.println(n);
										map.put(n,1);
										}
									}	//System.out.println(n);
										solve(l,r,n*2);

										solve(l,r,n*3);
									
																	
											
									
									return;
								}
								
								
								static class Helper{
									int val;int index;
									public Helper(int  val,int index) {
										
										this.val=val;
										this.index=index;
										// TODO Auto-generated constructor stub
									}
								}
							
						
								
				
							    static boolean isPrime(int n) 
							    { 
							        // Corner cases 
							        if (n <= 1) 
							            return false; 
							        if (n <= 3) 
							            return true; 
							  
							        // This is checked so that we can skip 
							        // middle five numbers in below loop 
							        if (n % 2 == 0 || n % 3 == 0) 
							            return false; 
							  
							        for (int i = 5; i * i <= n; i = i + 6) 
							            if (n % i == 0 || n % (i + 2) == 0) 
							                return false; 
							  
							        return true; 
							    } 
						
								      
								    /* Iterative Function to calculate 
								       (x^y)%p in O(log y) */
								    static long power(long x, long y, long p) 
								    { 
								        // Initialize result 
								        long res = 1;      
								         
								        // Update x if it is more   
								        // than or equal to p 
								        x = x % p;  
								  
								       if (x == 0) return 0; // In case x is divisible by p;    
								  
								        while (y > 0) 
								        { 
								            // If y is odd, multiply x 
								            // with result 
								            if((y & 1)==1) 
								                res = (res * x) % p; 
								      
								            // y must be even now 
								            // y = y / 2 
								            y = y >> 1;  
								            x = (x * x) % p;  
								        } 
								        return res; 
								    } 
					
								
								
								
								  static class InputReader {
								        private InputStream stream;
								        private byte[] buf = new byte[1024];
								        private int curChar;
								        private int numChars;
								        private SpaceCharFilter filter;
							
								        public InputReader(InputStream stream) {
								            this.stream = stream;
								        }
							
								        public int read() {
								            if (numChars == -1)
								                throw new InputMismatchException();
								            if (curChar >= numChars) {
								                curChar = 0;
								                try {
								                    numChars = stream.read(buf);
								                } catch (IOException e) {
								                    throw new InputMismatchException();
								                }
								                if (numChars <= 0)
								                    return -1;
								            }
								            return buf[curChar++];
								        }
							
								        public int readInt() {
								            int c = read();
								            while (isSpaceChar(c))
								                c = read();
								            int sgn = 1;
								            if (c == '-') {
							    sgn = -1;
							    c = read();
							}
							int res = 0;
							do {
							    if (c < '0' || c > '9')
							        throw new InputMismatchException();
							    res *= 10;
							    res += c - '0';
							        c = read();
							    } while (!isSpaceChar(c));
							    return res * sgn;
							}
							
							public String readString() {
							    int c = read();
							    while (isSpaceChar(c))
							        c = read();
							    StringBuilder res = new StringBuilder();
							    do {
							        res.appendCodePoint(c);
							        c = read();
							    } while (!isSpaceChar(c));
							    return res.toString();
							}
							
							public boolean isSpaceChar(int c) {
							    if (filter != null)
							        return filter.isSpaceChar(c);
							    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
								        }
							
								        public String next() {
								            return readString();
								        }
							
								    }
								
								  public interface SpaceCharFilter {
								        public boolean isSpaceChar(int ch);
								    }	
								
								
																	
																	
																	
														
							}
							    