#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a),end(a)
#define FOR(x,val,to) for(int x=(val);x<int((to));++x)
#define FORE(x,val,to) for(auto x=(val);x<=(to);++x)
#define FORR(x,arr) for(auto &x: arr)
#define FORS(x,plus,arr) for(auto x = begin(arr)+(plus); x != end(arr); ++x)
#define FORREV(x,plus,arr) for(auto x = (arr).rbegin()+(plus); x !=(arr).rend(); ++x)
#define REE(s_) {cout<<s_<<'\n';exit(0);}
#define GET(arr) for(auto &i: (arr)) sc(i)
#define whatis(x) cerr << #x << " is " << (x) << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;

#ifdef ONLINE_JUDGE
#define whatis(x) ;
#endif
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template<class L, class R> ostream& operator<<(ostream &os, map<L, R> P) { for(auto const &vv: P)os<<"("<<vv.first<<","<<vv.second<<")"; return os; }
template<class T> ostream& operator<<(ostream &os, set<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class T> ostream& operator<<(ostream &os, vector<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class L, class R> ostream& operator<<(ostream &os, pair<L, R> P) { os<<"("<<P.first<<","<<P.second<<")"; return os; }
inline int fstoi(const string &str){auto it=str.begin();bool neg=0;int num=0;if(*it=='-')neg=1;else num=*it-'0';++it;while(it<str.end()) num=num*10+(*it++-'0');if(neg)num*=-1;return num;}
inline void getch(char &x){while(x = getchar_unlocked(), x < 33){;}}
inline void getstr(string &str){str.clear(); char cur;while(cur=getchar_unlocked(),cur<33){;}while(cur>32){str+=cur;cur=getchar_unlocked();}}
template<typename T> inline bool sc(T &num){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){if(c == EOF) return false;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; return true;}template<typename T, typename ...Args> inline void sc(T &num, Args &...args){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; sc(args...); }
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; //s.find_by_order(), s.order_of_key() <- works like lower_bound
template<typename T> using ordered_map = tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define N 1000001

/* ll dp[20][2520][512][2]; */
// dla uproszczenia mogę dać też 0 i guess
/* ll dp[20][2520][1024][2]; */
// ale wtedy nz wsm jeszcze potrzebuje
// albo wsm, po prostu jak mam m == 0, i nxtd == 0, to nie |= 1 i tyle
// -> nice
/* ll dp[20][2520][1024][2]; */
ll dp[2][2520][1024][2];
// wyliczenie w czasie kompilacji kappa XD

// oh wait, nie pomyślałem o pamięci ofc xd
// mogę podzielić przez 20, trzymając tylko sąsiednie i -> ez 40MB
// też ew jakbym nie trzymał dla zera do raczej git
// i dppre git, bo nie trzymam t

// 5.1s na pc tak po prostu full state full online bez optymalizacji / bfsa
// if(!dp[i][mod][m][t]) continue; -> 1.3s
// kolejka -> 12s (not worth it duh)
// dp[n]* -> dp[2]* -> 1.06s
ll qu(string s){
    FORR(i,s)
        i -= '0';
    memset(dp,0,sizeof dp);
    int n = s.size();
    // dont forget the base case duhh
    dp[0][0][0][0] = 1;
    /* vector<array<int,3>> qu; */
    // kolejka niezerowych statow
    /* qu.push_back({0,0,0}); */
    // nz i guess
    for(int i = 0; i < n; ++i){
        /* vector<array<int,3>> nqu; */
        whatis(i)
        /* FORR(x,qu){ */
        /*     auto [mod,m,t] = x; */
        int ii = i & 1;
        memset(dp[ii^1], 0, sizeof dp[ii^1]);
        for(int mod = 0; mod < 2520; ++mod){
            for(int m = 0; m < 1024; ++m){
                for(int t = 0; t < 2; ++t){
                    /* if(!dp[i][mod][m][t]) continue; */
                    if(!dp[ii][mod][m][t]) continue;
                    /* for(int d = 1; d < 10; ++d){ */
                    // dla uproszczenia
                    for(int d = 0; d < 10; ++d){
                        if(!t && d > s[i]) continue;
                        int nt = t | (d < s[i]);
                        // precomp mod * 10 % mod -> if zamiast % operator?
                        int nmod = (mod * 10 + d) % 2520;
                        /* int nm = m | (1 << (d-1)); */
                        // dla uproszczenia
                        /* int nm = (mod || d ? m | (1 << d) : 0); */
                        // nicee
                        // XDDDD nice to jest bug w tym
                        // mod || d zamiast m || d XD
                        // fixed -> ez passes Paluszek test
                        int nm = (m || d ? m | (1 << d) : 0);
                        /* dp[i+1][nmod][nm][nt] += dp[i][mod][m][t]; */
                        dp[ii^1][nmod][nm][nt] += dp[ii][mod][m][t];
                        /* nqu.push_back({nmod,nm,nt}); */
                    }
                }
            }
        }
            /* dp[i][mod][m][t] = 0; */
        /* } */
        /* qu = nqu; */
    }
    ll ret = 0;
    int nn = n & 1;
    for(int i = 2; i < 1 << 10; i += 2){
        int nww = 1;
        for(int x = 1; x < 10; ++x){
            if(i & (1 << x)){
                nww = nww * x / __gcd(nww, x);
            }
        }
        // assert miałem zły xd
        /* assert(nww <= 2520); */
        // wait, ale wsm przecież dobrze było lol
        // jakby na to samo wychodzi tera?
        // ale assert not failed somehow
        // nie no, jest failed
        /* if(nww == 2520) */
        /*     nww = 0; */
        assert(nww <= 2520);
        assert(2520 % nww == 0);
        /* assert(!nww || 2520 % nww == 0); */
        /* if(nww){ */
        for(int x = 0; x < 2520; x += nww){
            /* ret += dp[n][x][i][0]; */
            /* ret += dp[n][x][i][1]; */
            ret += dp[nn][x][i][0];
            ret += dp[nn][x][i][1];
        }
        /* } */
        /* else{ */
        /*     /1* ret = dp[n][0][i][0]; *1/ */
        /*     /1* ret = dp[n][0][i][1]; *1/ */
        /*     ret += dp[n][0][i][0]; */
        /*     ret += dp[n][0][i][1]; */
        /* } */
    }
    return ret;
}
//
// constexpr można ez
/* ll dppre[20][2520][1024]; */
/* void pre(){ */
/*     // Traktując pos == 0 jako końcowy state -> jaki ma wkład w odpowiedź */
/*     // Jeśli tylko 1 dobry state, to tylko jedno = 1 na początku */
/*     // takie że mod % nww(mask) == 0 */
/*     /1* FOR(i,0,155){ *1/ */
/*     /1*     dppre[0][i] = i; *1/ */
/*     /1* } *1/ */
/*     for(int m = 2; m < 1024; ++m){ */
/*         int nww = 1; */
/*         for(int x = 1; x < 10; ++x){ */
/*             if(m & (1 << x)){ */
/*                 nww = nww * x / __gcd(nww, x); */
/*             } */
/*         } */
/*         for(int x = 0; x < 2520; x += nww){ */
/*             ++dppre[0][x][m]; */
/*         } */
/*     } */
/*     for(int i = 1; i < 20; ++i){ */
/*         for(int mod = 0; mod < 2520; ++mod){ */
/*             for(int m = 0; m < 1024; ++m){ */
/*                 for(int d = 0; d < 10; ++d){ */
/*                     int nmod = (mod * 10 + d) % 2520; */
/*                     int nm = (m || d ? m | (1 << d) : 0); */
/*                     dppre[i][mod][m] += dppre[i-1][nmod][nm]; */
/*                 } */
/*             } */
/*         } */
/*     } */
/* } */

/* // Liniowe od długości liczby, bo zawsze jest tylko n statów z t == 0 (limitem) */
/* ll qupostpre(string n){ */
/*     ll res = 0; */
/*     for(auto &i: n){ */
/*         i -= '0'; */
/*     } */
/*     int len = n.size(); */
/*     int suma = 0; */
/*     for(int i = 0; i < len; ++i){ */
/*         for(int d = 0; d < n[i]; ++d){ */
/*             int nsuma = suma + d; */
/*             res += dppre[len - i - 1][nsuma]; */
/*         } */
/*         // Next state dla d == n[i], czyli jedynego dalszego z t == 0 */
/*         suma = suma + n[i]; */
/*     } */
/*     // W pętli wyliczane jest exclusive samo n, więc na końcu trzeba dodać */
/*     // wynik dla całej liczby, a mamy zapisany state końcowy w zmiennych */
/*     res += suma; */
/*     return res; */
/* } */

bool onequ(ll n){
    ll nn = n;
    int mm = 0;
    while(nn){
        mm |= 1 << (nn % 10);
        nn /= 10;
    }
    int nww = 1;
    for(int x = 1; x < 10; ++x){
        if(mm & (1 << x)){
            nww = nww * x / __gcd(nww, x);
        }
    }
    return (mm % 2 == 0) && n % nww == 0;
    for(int x = 0; x < 10; ++x){
        if(mm & (1 << x)){
            if(!x || n % x){
                assert(!x || n % nww);
                return false;
            }
        }
    }
    assert(n % nww == 0);
    return true;
}

int bfrange(int l, int r){
    int res = 0;
    for(int i = l; i <= r; ++i)
        res += onequ(i);
    return res;
}

int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);
    int t = 1;
    /* whatis(bfrange(1,1000)) */
    /* whatis(bfrange(1,252001)) */
    /* for(int i = 1; i < 1000; ++i){ */
    /*     whatis(i) */
    /*     assert(onequ(i) == (qu(to_string(i)) - qu(to_string(i-1)))); */
    /* } */
    /* int wh = 252001; */
    // assert failed
    /* assert(onequ(wh) == (qu(to_string(wh)) - qu(to_string(wh-1)))); */
    /* cin >> t; */
    string a,b;
    /* pre(); */
    while(t--){
        cin >> a >> b;
        ll res = qu(b);
        if(a.size() > 1 || a[0] != '0'){
            if(a == "1"){
                a = "0";
            }
            else{
                auto it = --a.end();
                while(it != a.begin() && *it == '0'){
                    *it = '9';
                    --it;
                }
                if(it == a.begin() && *it == '1')
                    a.erase(a.begin());
                else
                    --*it;
            }
            res -= qu(a); // IF MODUOLING, DON'T FORGET TO CORRECT IN CASE RES GOES NEGATIVE
        }
        cout << res << '\n';
        /* ll res2 = qupostpre(b) - qupostpre(a); */
        /* cout << res2 << '\n'; */
    }
}