#include <bits/stdc++.h>
using namespace std;
#define LOCAL
#pragma region Macros
typedef long long ll;
#define ALL(x) (x).begin(),(x).end()
const long long MOD=1000000007;
// const long long MOD=998244353;
const int INF=1e9;
const long long IINF=1e18;
const int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
const char dir[4]={'D','R','U','L'};

template<typename T>
istream &operator>>(istream &is,vector<T> &v){
    for (T &x:v) is >> x;
    return is;
}
template<typename T>
ostream &operator<<(ostream &os,const vector<T> &v){
    for (int i=0;i<v.size();++i){
        os << v[i] << (i+1==v.size()?"": " ");
    }
    return os;
}
template<typename T,typename U>
ostream &operator<<(ostream &os,const pair<T,U> &p){
    os << '(' << p.first << ',' << p.second << ')';
    return os;
}
template<typename T,typename U>
ostream &operator<<(ostream &os,const map<T,U> &m){
    os << '{';
    for (auto itr=m.begin();itr!=m.end();++itr){
        os << '(' << itr->first << ',' << itr->second << ')';
        if (++itr!=m.end()) os << ',';
        --itr;
    }
    os << '}';
    return os;
}
template<typename T>
ostream &operator<<(ostream &os,const set<T> &s){
    os << '{';
    for (auto itr=s.begin();itr!=s.end();++itr){
        os << *itr;
        if (++itr!=s.end()) os << ',';
        --itr;
    }
    os << '}';
    return os;
}

void debug_out(){cerr << '\n';}
template<class Head,class... Tail>
void debug_out(Head&& head,Tail&&... tail){
    cerr << head;
    if (sizeof...(Tail)>0) cerr << ", ";
    debug_out(move(tail)...);
}
#ifdef LOCAL
#define debug(...) cerr << " ";\
cerr << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" << '\n';\
cerr << " ";\
debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

template<typename T> T gcd(T x,T y){return y!=0?gcd(y,x%y):x;}
template<typename T> T lcm(T x,T y){return x/gcd(x,y)*y;}

template<class T1,class T2> inline bool chmin(T1 &a,T2 b){
    if (a>b){a=b; return true;} return false;
}
template<class T1,class T2> inline bool chmax(T1 &a,T2 b){
    if (a<b){a=b; return true;} return false;
}
#pragma endregion

template<uint32_t mod> class modint{
    using i64=int64_t;
    using u32=uint32_t;
    using u64=uint64_t;
public:
    u32 v;
    constexpr modint(const i64 x=0) noexcept :v(x<0?mod-1-(-(x+1)%mod):x%mod){}
    constexpr u32 &value() noexcept {return v;}
    constexpr const u32 &value() const noexcept {return v;}
    constexpr modint operator+(const modint &rhs) const noexcept {return modint(*this)+=rhs;}
    constexpr modint operator-(const modint &rhs) const noexcept {return modint(*this)-=rhs;}
    constexpr modint operator*(const modint &rhs) const noexcept {return modint(*this)*=rhs;}
    constexpr modint operator/(const modint &rhs) const noexcept {return modint(*this)/=rhs;}
    constexpr modint &operator+=(const modint &rhs) noexcept {
        v+=rhs.v;
        if (v>=mod) v-=mod;
        return *this;
    }
    constexpr modint &operator-=(const modint &rhs) noexcept {
        if (v<rhs.v) v+=mod;
        v-=rhs.v;
        return *this;
    }
    constexpr modint &operator*=(const modint &rhs) noexcept {
        v=(u64)v*rhs.v%mod;
        return *this;
    }
    constexpr modint &operator/=(const modint &rhs) noexcept {
        return *this*=rhs.pow(mod-2);
    }
    constexpr modint pow(u64 exp) const noexcept {
        modint self(*this),res(1);
        while (exp>0){
            if (exp&1) res*=self;
            self*=self; exp>>=1;
        }
        return res;
    }
    constexpr modint &operator++() noexcept {if (++v==mod) v=0; return *this;}
    constexpr modint &operator--() noexcept {if (v==0) v=mod; return --v,*this;}
    constexpr modint operator++(int) noexcept {modint t=*this; return ++*this,t;}
    constexpr modint operator--(int) noexcept {modint t=*this; return --*this,t;}
    template<class T> friend constexpr modint operator+(T x,modint y) noexcept {return modint(x)+y;}
    template<class T> friend constexpr modint operator-(T x,modint y) noexcept {return modint(x)-y;}
    template<class T> friend constexpr modint operator*(T x,modint y) noexcept {return modint(x)*y;}
    template<class T> friend constexpr modint operator/(T x,modint y) noexcept {return modint(x)/y;}
    constexpr bool operator==(const modint &rhs) const noexcept {return v==rhs.v;}
    constexpr bool operator!=(const modint &rhs) const noexcept {return v!=rhs.v;}
    constexpr bool operator!() const noexcept {return !v;}
    friend istream &operator>>(istream &s,modint &rhs) noexcept {
        i64 v; rhs=modint{(s>>v,v)}; return s;
    }
    friend ostream &operator<<(ostream &s,const modint &rhs) noexcept {
        return s<<rhs.v;
    }
};

template<int char_size>
struct Trie{
    struct TrieNode{
        char c; int dep;
        vector<int> nxt,idxs;
        TrieNode(char c,int dep):c(c),dep(dep),nxt(char_size,-1){}
    };
    vector<TrieNode> Nodes;
    function<int(char)> ctoi;
    Trie(function<int(char)> ctoi):ctoi(ctoi){
        Nodes.emplace_back('$',0);
    }
    inline int &next(int node,int c){
        return Nodes[node].nxt[c];
    }
    inline int &next(int node,char c){
        return next(node,ctoi(c));
    }
    void add(const string &s,int x=0){
        int node=0;
        for (int i=0;i<s.size();++i){
            int k=ctoi(s[i]);
            if (next(node,k)<0){
                next(node,k)=Nodes.size();
                Nodes.emplace_back(s[i],i+1);
            }
            node=next(node,k);
        }
        Nodes[node].idxs.emplace_back(x);
    }
    int find(const string &s){
        int node=0;
        for (int i=0;i<s.size();++i){
            int k=ctoi(s[i]);
            if (next(node,k)<0) return -1;
            node=next(node,k);
        }
        return node;
    }
    template<typename F>
    void query(const string &s,const F &f,int l){
        int node=0;
        for (int i=l;i<s.size();++i){
            node=next(node,s[i]);
            if (node<0) return;
            for (auto &idx:Nodes[node].idxs) f(idx);
        }
    }
    int size(){return Nodes.size();};
    vector<int> idxs(int node){return Nodes[node].idxs;}
};

template<int char_size>
struct AhoCorasick:Trie<char_size+1>{
    using Trie<char_size+1>::Trie;
    using Trie<char_size+1>::next;
    using Trie<char_size+1>::ctoi;
    const int FAIL=char_size;
    vector<int> cnt;
    void build(bool heavy=true){
        auto &Nodes=this->Nodes;
        cnt.resize(Nodes.size());
        for (int i=0;i<Nodes.size();++i){
            cnt[i]=Nodes[i].idxs.size();
        }
        queue<int> que;
        for (int i=0;i<=char_size;++i){
            if (~next(0,i)){
                next(next(0,i),FAIL)=0;
                que.emplace(next(0,i));
            } else next(0,i)=0;
        }
        while (!que.empty()){
            auto &node=Nodes[que.front()];
            cnt[que.front()]+=cnt[node.nxt[FAIL]];
            que.pop();
            for (int i=0;i<char_size;++i){
                if (node.nxt[i]<0) continue;
                int fail=node.nxt[FAIL];
                while (next(fail,i)<0) fail=next(fail,FAIL);
                next(node.nxt[i],FAIL)=next(fail,i);
                if (heavy){
                    auto &u=Nodes[node.nxt[i]].idxs;
                    auto &v=Nodes[next(fail,i)].idxs;
                    vector<int> w;
                    set_union(u.begin(),u.end(),v.begin(),v.end(),back_inserter(w));
                    u=w;
                }
                que.emplace(node.nxt[i]);
            }
        }
    }
    map<int,int> match(const string &s,int now=0){
        auto &Nodes=this->Nodes;
        map<int,int> res;
        for (auto c:s){
            while (next(now,ctoi(c))<0) now=next(now,FAIL);
            now=next(now,ctoi(c));
            for (auto &id:Nodes[now].idxs) ++res[id];
        }
        return res;
    }
    int move(int now,const char &c){
        while (next(now,ctoi(c))<0) now=next(now,FAIL);
        return next(now,ctoi(c));
    }
    int count(int node){return cnt[node];}
};

using mint=modint<MOD>;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N; ll L,R; cin >> N >> L >> R;

    vector<ll> fib(2);
    fib[0]=fib[1]=1;
    for (int i=2;fib[i-1]+fib[i-2]<=R;++i){
        fib.emplace_back(fib[i-1]+fib[i-2]);
    }
    AhoCorasick<10> AHO([](char c){return c-'0';});
    for (ll f:fib){
        if (L<=f){
            AHO.add(to_string(f));
        }
    }
    AHO.build(false);

    int n=AHO.size();
    vector<vector<mint>> dp(N+1,vector<mint>(n,0));
    dp[0][0]=1;
    for (int i=0;i<N;++i){
        for (int j=0;j<n;++j){
            for (int k=0;k<10;++k){
                int nxt=AHO.move(j,'0'+k);
                if (!AHO.count(nxt)) dp[i+1][nxt]+=dp[i][j];
            }
        }
    }

    mint ans=0;
    for (int j=0;j<n;++j) ans+=dp[N][j];
    cout << ans-1 << '\n';
}