#include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(),(v).end()
#define pb(a) push_back(a)
#define rep(i, n) for(int i=0;i<n;i++)
#define foa(e, v) for(auto& e : v)
using ll = long long;
const ll MOD7 = 1000000007, MOD998 = 998244353, INF = (1LL << 60);
#define dout(a) cout<<fixed<<setprecision(10)<<a<<endl;

template<int MOD> struct Modint {
    long long val;
    constexpr Modint(long long v = 0) noexcept : val(v % MOD) { if (val < 0) val += MOD; }
    constexpr int mod() const { return MOD; }
    constexpr long long value() const { return val; }
    constexpr Modint operator - () const noexcept { return val ? MOD - val : 0; }
    constexpr Modint operator + (const Modint& r) const noexcept { return Modint(*this) += r; }
    constexpr Modint operator - (const Modint& r) const noexcept { return Modint(*this) -= r; }
    constexpr Modint operator * (const Modint& r) const noexcept { return Modint(*this) *= r; }
    constexpr Modint operator / (const Modint& r) const noexcept { return Modint(*this) /= r; }
    constexpr Modint& operator += (const Modint& r) noexcept {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return *this;
    }
    constexpr Modint& operator -= (const Modint& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr Modint& operator *= (const Modint& r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Modint& operator /= (const Modint& r) noexcept {
        long long a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b, swap(a, b);
            u -= t * v, swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr bool operator == (const Modint& r) const noexcept { return this->val == r.val; }
    constexpr bool operator != (const Modint& r) const noexcept { return this->val != r.val; }
    friend constexpr istream& operator >> (istream& is, Modint<MOD>& x) noexcept {
        is >> x.val;
        x.val %= MOD;
        if (x.val < 0) x.val += MOD;
        return is;
    }
    friend constexpr ostream& operator << (ostream& os, const Modint<MOD>& x) noexcept {
        return os << x.val;
    }
    constexpr Modint<MOD> pow(long long n) noexcept {
        if (n == 0) return 1;
        if (n < 0) return this->pow(-n).inv();
        Modint<MOD> ret = pow(n >> 1);
        ret *= ret;
        if (n & 1) ret *= *this;
        return ret;
    }
    constexpr Modint<MOD> inv() const noexcept {
        long long a = this->val, b = MOD, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b, swap(a, b);
            u -= t * v, swap(u, v);
        }
        return Modint<MOD>(u);
    }
};

const int MOD = MOD7;
using mint = Modint<MOD>;



mint solve(string s, ll k) {
    vector<vector<ll>> cc(10, vector(10, 0LL));
    for(ll i = 0; i < 10; i ++) {
        if(i == 0) {
            rep(j, 10) cc[i][j] = 1000;
        } else {
            ll num = i;
            for(ll j = 2; j < 10; j ++) {
                while(num % j == 0) {
                    num /= j;
                    cc[i][j] ++;
                }
            }
        }
    } 
    vector<ll> c(10, 0);
    for(ll i = 2; i < 10; i ++) {
        while(k % i == 0) {
            k /= i;
            c[i] ++;
        }
    }
    if(k > 1) {
        mint ans = 0;
        int n = s.size();
        for(int i = 0; i < n; i ++) {
            int num = s[i] - '0';
            for(int j = 1; j < num; j ++) {
                ans += mint(10).pow(n - i - 1) - mint(9).pow(n - i - 1);
            }
            if(num == 0) {
                ans += mint(1);
                for(int j = i + 1; j < n; j ++) {
                    ans += mint(10).pow(n - j - 1) * mint(s[j] - '0');
                }
                break;
            }
            if(i) {
                ans += mint(10).pow(n - i - 1);
            }
        }
        for(int d = 2; d < n; d ++) {
            ans += mint(9) * (mint(10).pow(d - 1) - mint(9).pow(d - 1));
        }
        return ans;
        
    }
    vector dp(c[2] + 1, vector(c[3] + 1, vector(c[5] + 1, vector(c[7] + 1, mint(0)))));
    mint ans = 0;
    ll n = s.size();
    vector<ll> now(10, 0);
    rep(i, n) {
        vector nx(c[2] + 1, vector(c[3] + 1, vector(c[5] + 1, vector(c[7] + 1, mint(0)))));
        rep(c2, c[2] + 1) {
            rep(c3, c[3] + 1) {
                rep(c5, c[5] + 1) {
                    rep(c7, c[7] + 1) {
                        for(int j = 0; j < 10; j ++) {
                            nx[min(c[2], c2 + cc[j][2])][min(c[3], c3 + cc[j][3])][min(c[5], c5 + cc[j][5])][min(c[7], c7 + cc[j][7])] 
                            += dp[c2][c3][c5][c7];
                        }
                    }
                }
            }
        }
        int num = s[i] - '0';
        vector<ll> nnx(10, 0);
        for(int j = 0; j < num; j ++) {
            if(i == 0 and j == 0) continue;
            nx[min(c[2], now[2] + cc[j][2])][min(c[3], now[3] + cc[j][3])][min(c[5], now[5] + cc[j][5])][min(c[7], now[7] + cc[j][7])] += mint(1);
        }
        if(i) {
            for(ll j = 1; j < 10; j ++) {
                nx[min(c[2], cc[j][2])][min(c[3], cc[j][3])][min(c[5], cc[j][5])][min(c[7], cc[j][7])] += mint(1);
            }
        }
        {
            for(ll x = 2; x < 10; x ++) {
                nnx[x] = now[x] + cc[num][x];
            }
        }
        swap(nnx, now);
        swap(nx, dp);
    }
    bool ng = 0;
    for(ll i = 2; i < 10; i ++) {
        if(now[i] < c[i]) ng = 1;
    }
    if(!ng) ans += mint(1);
    ans += dp[c[2]][c[3]][c[5]][c[7]];
    return ans;
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll k;
    cin >> k;
    string l, r;
    cin >> l >> r;
    if(l == "1") {
        cout << solve(r, k) << endl;
    } else {
        reverse(all(l));
        int n = l.size();
        rep(i, n) {
            if(l[i] > '0') {
                int num = l[i] - '0';
                l[i] = char('0' + (num - 1));
                break;
            } else {
                l[i] = '9';
            }
        }
        if(l.back() == '0') l.pop_back();
        reverse(all(l));
        cout << solve(r, k) - solve(l, k) << endl;
    }
    return 0;
}