#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = (int)(s); i < (int)(n); i++)
#define all(v) begin(v),end(v)
using namespace std;
using ll = long long;
bool chmin(auto &a, auto b) { return a > b ? a = b, 1 : 0; }
bool chmax(auto &a, auto b) { return a < b ? a = b, 1 : 0; }

using bll = __int128_t;
bll input(){
    string s; cin >> s;
    bll x = 0;
    for (auto c : s){
        x = x * 10 + (c - '0');
    }
    return x;
}

string tostr(bll x){
    string s = "";
    while (x > 0){
        s += '0' + (x % 10);
        x /= 10;
    }
    reverse(all(s));
    return s;
}

template<int mod>
struct mm {
    using uint = unsigned int;
    uint x;
    mm (uint _x = 0) : x(_x) {}
    mm &operator+=(mm a){
        x += a.x;
        if (x >= mod) x -= mod;
        return *this;
    }
    mm &operator-=(mm a){
        x += mod - a.x;
        if (x >= mod) x -= mod;
        return *this;
    }
    friend mm operator+(mm a, mm b){
        return a += b;
    }
    friend mm operator-(mm a, mm b){
        return a -= b;
    }
};
using mint = mm<1'000'000'007>;

using ar = array<int,4>;

pair<ar,ll> div2357(ll k){
    ar ret = {};
    ar ds = {2,3,5,7};
    rep(i,0,4){
        while (k % ds[i] == 0){
            ret[i]++;
            k /= ds[i];
        }
    }
    return {ret,k};
}

mint naive(ll k, string s){
    ll r = stoll(s);
    mint ans = 0;
    for (ll x = 1; x <= r; x++){
        string t = to_string(x);
        ll prd = 1;
        for (auto c : t){
            prd *= (c - '0');
        }
        if (prd % k == 0){
            ans += 1;
        }
    }
    return ans;
}

mint calc(ll k, string s){
    if (s.empty()){
        return 0;
    }
    auto [ds, nk] = div2357(k);
    // odd, small, l0, c2, c3, c5, c7
    static mint dp[2][2][2][62][41][21][21] = {};
    memset(dp,0,sizeof(dp));
    dp[0][0][0][0][0][0][0] = 1;
    auto nxt = [&](int i, int j, int a, int b, int c, int d, int sp, int p) -> array<int,6> {
        if (i == 0 && sp < p) return {-1};
        int ni = (i == 1 ? 1 : sp > p ? 1 : 0);
        if (j == 0 && p == 0){
            return {ni,0,0,0,0,0};
        }
        int nj = 1;
        if (a == ds[0]+1){
            return {ni,nj,ds[0]+1,0,0,0};
        }
        if (p == 0){
            a = ds[0]+1;
            b = 0;
            c = 0;
            d = 0;
            return {ni,nj,a,b,c,d};
        }
        if (p == 1){
            // nothing
        }
        else if (p == 2){
            a += 1;
        }
        else if (p == 3){
            b += 1;
        }
        else if (p == 4){
            a += 2;
        }
        else if (p == 5){
            c += 1;
        }
        else if (p == 6){
            a += 1;
            b += 1;
        }
        else if (p == 7){
            d += 1;
        }
        else if (p == 8){
            a += 3;
        }
        else if (p == 9){
            b += 2;
        }
        chmin(a,ds[0]);
        chmin(b,ds[1]);
        chmin(c,ds[2]);
        chmin(d,ds[3]);
        return {ni,nj,a,b,c,d};
    };
    // dp[t] contains ans
    int t = 0, f = 1;
    for (auto cc : s){
        int sp = cc - '0';
        swap(f,t);
        // dp[f] -> dp[t]
        rep(i,0,2) rep(j,0,2) rep(a,0,ds[0]+2) rep(b,0,ds[1]+1) rep(c,0,ds[2]+1) rep(d,0,ds[3]+1){
            dp[t][i][j][a][b][c][d] = 0;
        }
        rep(i,0,2) rep(j,0,2) rep(a,0,ds[0]+2) rep(b,0,ds[1]+1) rep(c,0,ds[2]+1) rep(d,0,ds[3]+1){
            rep(p,0,10){
                auto [ni,nj,na,nb,nc,nd] = nxt(i,j,a,b,c,d,sp,p);
                if (ni == -1) continue;
                dp[t][ni][nj][na][nb][nc][nd] += dp[f][i][j][a][b][c][d];
            }
        }
    }
    mint ans = dp[t][0][1][ds[0]+1][0][0][0] + dp[t][1][1][ds[0]+1][0][0][0];
    if (nk == 1){
        ans += dp[t][0][1][ds[0]][ds[1]][ds[2]][ds[3]];
        ans += dp[t][1][1][ds[0]][ds[1]][ds[2]][ds[3]];
    }
    // cout << k << ' ' << s << endl;
    // cout << ans.x << endl;
    return ans;
}

void solve(){
    ll k; cin >> k;
    bll l = input();
    bll r = input();
    l--;
    string sl = tostr(l);
    string sr = tostr(r);
    mint ans = calc(k,sr) - calc(k,sl);
    cout << ans.x << '\n';
    // mint nans = naive(k,sr) - calc(k,sl);
    // cout << nans.x << '\n';
}

int main(){
    cin.tie(0)->sync_with_stdio(0);
    solve();
}