#include <bits/stdc++.h>

using namespace std;

template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
istream& operator>>(istream &s, T &&v) { for (auto &&x : v) s >> x; return s; }
template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
ostream& operator<<(ostream &s, T &&v) { for (auto &&x : v) s << x << ' '; return s; }

#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << x << e, e = ' '), ...); }
#define debug(x...) dbg(#x, '=', x, '\n')
#else
#define debug(...) ((void)0)
#endif
#define all(v) (v).begin(), (v).end()
#define ff first
#define ss second

template<class T> bool chmin(T &a, T b) { return (b < a) and (a = b, true); }
template<class T> bool chmax(T &a, T b) { return (a < b) and (a = b, true); }
template<class T> inline constexpr T inf = numeric_limits<T>::max() / 2;

using i64 = long long;

constexpr i64 mod = 1e9 + 7;

void solve() {
    i64 k;
    string L, R;
    cin >> k >> L >> R;

    using state = array<i64, 4>;

    auto upd = [&](state v, int x) -> state {
        if (v[0] == -1) return v;
        if (x == 0) return state{-1, 0, 0, 0};
        for (int i = 0; int p : {2, 3, 5, 7}) {
            int c = 0;
            while (x % p == 0) {
                c++;
                x /= p;
            }
            v[i] += c;
            i++;
        }
        return v;
    };

    auto DP = [&upd](string_view S, bool e) -> map<state, i64> {
        map<state, i64> dp1, dp0;
        dp1[state{0, 0, 0, 0}] = 1;
        for (char c : S) {
            int d = c - '0';
            decltype(dp0) f0, f1;
            for (int i = 0; i < 10; i++) {
                if (i < d) {
                    for (auto &[s, v] : dp0)
                        (f0[upd(s, i)] += v) %= mod;
                    for (auto &[s, v] : dp1)
                        (f0[upd(s, i)] += v) %= mod;
                } else if (i == d) {
                    for (auto &[s, v] : dp0)
                        (f0[upd(s, i)] += v) %= mod;
                    for (auto &[s, v] : dp1)
                        (f1[upd(s, i)] += v) %= mod;
                } else {
                    for (auto &[s, v] : dp0)
                        (f0[upd(s, i)] += v) %= mod;
                }
            }
            dp0.swap(f0);
            dp1.swap(f1);
            dp0[state{-1, 0, 0, 0}]--;
            dp0[state{0, 0, 0, 0}]++;
        }
        if (e)
            for (auto &[s, v] : dp1)
                (dp0[s] += v) %= mod;
        return dp0;
    };

    auto dpR = DP(R, 1);
    auto dpL = DP(L, 0);

    if (0) {
        for (auto [s, v] : dpR) {
            debug(s, v);
        }
        debug("=====");
        for (auto [s, v] : dpL) {
            debug(s, v);
        }
        debug("=====");
    }

    for (auto &[s, v] : dpL) {
        (dpR[s] += mod - v) %= mod;
    }

    state cur{0, 0, 0, 0};
    for (int i = 0; int p : {2, 3, 5, 7}) {
        int c = 0;
        while (k % p == 0) {
            c++;
            k /= p;
        }
        cur[i] += c;
        i++;
    }

    // debug(k, cur);

    i64 ans = 0;
    for (auto &[s, v] : dpR) {
        // debug(s, v);
        if (k == 1 and s[0] != -1) {
            bool ok = true;
            for (int i = 0; i < 4; i++)
                ok &= (s[i] >= cur[i]);
            if (ok) ans += v;
        }
        if (s == state{-1, 0, 0, 0}) {
            ans += v;
        }
        ans %= mod;
    }

    cout << ans << '\n';
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    solve();
    return 0;
}