#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

const int MOD = 1'000'000'009;

using ull = unsigned long long;
template <int MD>
struct ModInt {
    using M = ModInt;
//    static int MD;
    int v;
    ModInt(ll _v = 0) { set_v(int(_v % MD + MD)); }
    inline M& set_v(int _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    inline explicit operator bool() const { return v != 0; }
    inline M operator-() const { return M() - *this; }
    inline M operator+(const M& r) const { return M().set_v(v + r.v); }
    inline M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    inline M operator*(const M& r) const { return M().set_v(int((ull)v * r.v % MD)); }
    inline M operator/(const M& r) const { return *this * r.inv(); }
    inline M& operator+=(const M& r) { return *this = *this + r; }
    inline M& operator-=(const M& r) { return *this = *this - r; }
    inline M& operator*=(const M& r) { return *this = *this * r; }
    inline M& operator/=(const M& r) { return *this = *this / r; }
    inline bool operator==(const M& r) const { return v == r.v; }
    inline bool operator!=(const M& r) const { return v != r.v; }
    inline M inv() const;
    inline friend istream& operator>>(istream& is, M& r) { ll x; is >> x; r = M(x); return is; }
    inline friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};

template<int MD>
ModInt<MD> pow(ModInt<MD> x, ll n) {
//ModInt pow(ModInt x, ll n) {
    ModInt<MD> r = 1;
    //ModInt r = 1;
    while (n) {
        if (n & 1) r *= x;
        x *= x;
        n >>= 1;
    }
    return r;
}

template<int MD>
ModInt<MD> ModInt<MD>::inv() const { return pow(*this, MD - 2); }
//ModInt ModInt::inv() const { return pow(*this, MD - 2); }

// if MD is from input
// this line is necessary, read later as you wish
//int ModInt::MD;

using Mint = ModInt<MOD>;
//using Mint = ModInt;

int n;

Mint dp[2][2][(1 << 9)];

Mint func(const string& s) {
    Mint dig_sum = 0;
    int d0 = s[0] - '0';
    {
        Mint pw = 1;
        for (int i = 0; i < n - 1; i++) {
            pw *= 10;
        }
        dig_sum += pw * (d0 * (d0 - 1) / 2);
    }
    {
        Mint cnt = 0;
        for (int i = 1; i < n; i++) {
            cnt = cnt * 10 + (s[i] - '0');
        }
        dig_sum += (cnt + 1) * d0;
    }

    memset(dp, 0, sizeof(dp));
    dp[0][1][0] = 1;
    for (int pos = 0; pos < n; pos++) {
        memset(dp[(pos + 1) & 1], 0, sizeof(dp[(pos + 1) & 1]));
        int d = s[pos] - '0';
        for (int dcur = 0; dcur < 10; dcur++) {
            for (int tp = 0; tp < 2; tp++) {
                if (tp == 1 && dcur > d) {
                    continue;
                }
                int new_tp = 0;
                if (tp == 1 && dcur == d) {
                    new_tp = 1;
                }
                for (int state = 0; state < (1 << 9); state++) {
                    if (dp[pos & 1][tp][state] == 0) {
                        continue;
                    }
                    int new_state = state;
                    if (dcur > 0) {
                        for (int i = dcur - 1; i >= 0; i--) {
                            if ((state >> i) & 1) {
                                new_state ^= (1 << i);
                                break;
                            }
                        }
                        new_state ^= (1 << (dcur - 1));
                    }
                    dp[(pos + 1) & 1][new_tp][new_state] += dp[pos & 1][tp][state];
                }
            }
        }
    }

    Mint ans = 0;
    for (int tp = 0; tp < 2; tp++) {
        for (int state = 0; state < (1 << 9); state++) {
            ans += dp[n & 1][tp][state] * __builtin_popcount(state) * 10;
        }
    }

    return ans - dig_sum;
}

void solve() {
    cin >> n;
    string l, r;
    cin >> l >> r;
    Mint ans = func(r);
    int p = -1;
    for (int i = n - 1; i >= 0; i--) {
        if (l[i] != '0') {
            p = i;
            break;
        }
    }
    if (p != -1) {
        l[p]--;
        for (int i = p + 1; i < n; i++) {
            l[i] = '9';
        }
        ans -= func(l);
    }
    cout << ans << "\n";
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}