program mins ;

const FIN = 'mins.in';
      FOU = 'mins.out';
      MAX = 1000015;

var V : array[0 .. 1 shl 17] of byte ;
    P : array[0 .. MAX] of int64 ;
    C, D, aux, i, j : int64 ;
    s : int64 ;
    f : text ;

procedure solve ( K : int64 ; prod : int64 ; N : int64 ; val : int64 ) ;
    begin
        if ( K > N ) or ( C  < prod * P[K] ) then
            begin
                if ( val and 1 = 1 ) then
                    s := s - ( D div prod ) * ( C div prod )
                else
                    s := s + ( D div prod ) * ( C div prod ) ;

                exit ;
            end;

        solve ( K + 1 , prod * P[K] , N, val + 1 ) ;
        solve ( K + 1 , prod , N , val ) ;
    end;


    begin
        assign ( f, FIN ) ; reset ( f ) ;

        readln ( f, C, D ) ; close ( f ) ;

        if ( C > D ) then
            begin
                aux := C ;
                C := D ;
                D := aux ;
            end;

       dec ( C ) ; dec ( D ) ;

       inc ( P[0] ) ; P[P[0]] := 2;

       i := 3 ;

       while ( i <= D ) do
           begin
               if ( V[i shr 4] ) and ( 1 shl ( ( i shr 1 ) and 7 ) ) <> 0 then
                   begin
                       inc ( i , 2 ) ;
                       continue ;
                   end;

               inc ( P[0] ) ; P[P[0]] := i ;

               j := i + ( i shl 1 ) ;

               while ( j <= D ) do
                   begin
                       V[j shr 4] := V[j shr 4] or ( 1 shl ( ( j shr 1 ) and 7 ) ) ;
                       inc ( j, i shl 1 ) ;
                   end;

               inc ( i, 2 ) ;
           end;

           solve ( 1, 1, P[0], 0 ) ;

           assign ( f, FOU ) ; rewrite ( f ) ;

           writeln ( f, s ) ;

           close ( f ) ;
       end.