#include <iostream>
#include <cstring>
#include <algorithm>
#define ll unsigned long long

#define ull unsigned long long

using namespace std;

ll dp[70000][2][20];

string num;
int step3[12];

inline ll res ( int mask,int k, int N ){
 //   cout << mask << " " << zero << " " << k << " " << N << endl;
    if ( dp[mask][k][N] != (ull)-1 ) return dp[mask][k][N];

    if ( N == num.size() ){
        int correct = 1;
        for ( int i = 0; i < 10; ++i )
            if ( ( mask % step3[i + 1] ) / step3[i] ){
                if ( i % 2 && ( mask % step3[i + 1] ) / step3[i] == 1 )
                correct = 0;
            else if ( i % 2 == 0 && ( mask % step3[i + 1] ) / step3[i] == 2 )
                correct = 0;
        }

       return dp[mask][k][N] = correct;
    }

    dp[mask][k][N] = 0;

    ll cur = 0;
    int zero = ( mask == 0 );

    if ( k ){
        if ( zero )
            cur += res ( mask, 0, N + 1 );

        for ( int i = zero; i <= num[N]; ++i ){
            int nk = ( i == (int)num[N] );

            if ( ( mask % step3[i + 1] ) / step3[i] == 0 ){
                ll tmp = dp[ mask + step3[i]][nk][ N + 1 ];

                if ( tmp == -1 )
                    cur += res ( mask + step3[i], nk, N + 1 );
                else cur += tmp;
            }
            else if ( ( mask % step3[i + 1] ) / step3[i] == 1 ){
                ll tmp = dp[ mask + step3[i]][nk][ N + 1 ];

                if ( tmp == (ull)-1 )
                cur += res ( mask + step3[i], nk, N + 1 );
                else cur += tmp;
            }
            else{
                ll tmp = dp[ mask - step3[i]][nk][ N + 1 ];

                if ( tmp == (ull)-1 )
                    cur += res ( mask - step3[i], nk, N + 1 );
                else cur += tmp;
            }

        }
    }

    else{
        if ( zero )
            cur += res ( mask, 0, N + 1 );

      for ( int i = zero; i <= 9; ++i ){
            int nk = 0;

            if ( ( mask % step3[i + 1] ) / step3[i] == 0 ){
                ll tmp = dp[ mask + step3[i]][nk][ N + 1 ];

                if ( tmp == -1 )
                    cur += res ( mask + step3[i], nk, N + 1 );
                else cur += tmp;
            }
            else if ( ( mask % step3[i + 1] ) / step3[i] == 1 ){
                ll tmp = dp[ mask + step3[i]][nk][ N + 1 ];

                if ( tmp == -1 )
                cur += res ( mask + step3[i], nk, N + 1 );
                else cur += tmp;
            }
            else{
                ll tmp = dp[ mask - step3[i]][nk][ N + 1 ];

                if ( tmp == -1 )
                    cur += res ( mask - step3[i],  nk, N + 1 );
                else cur += tmp;
            }

        }
    }

    return dp[mask][k][N] = cur;
}


ll f ( ll N ){
    if ( N == 0 ) return 1;

    memset ( dp, -1, sizeof ( dp ) );


    num = "";
    ll k = N;

    while ( k ){
        num += ( k % 10 );
        k /= 10;
    }

    reverse ( num.begin(), num.end() );

    ll ans = 0;

    ans += res ( 0, 0, 1 );
    for ( int i = 1; i < num[0]; ++i )
        ans += res ( step3[i] , 0, 1 );

    ans += res ( step3[num[0]], 1, 1 );

    return ans;
}

void fill(){
    step3[0] =1 ;

    for ( int i = 1; i <= 10; ++i )
        step3[i] = step3[i - 1] * 3;
}

int main(){
    ll a, b;

    cin >> a >> b;
    fill();

    cout << f ( b ) - f ( a - 1 ) << endl;
}
