#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<uint_fast64_t Modulus> class modint{
    using u64=uint_fast64_t;
public:
    u64 a;
    constexpr modint(const u64 x=0) noexcept:a(x%Modulus){}
    constexpr u64 &value() noexcept{return a;}
    constexpr const u64 &value() const noexcept{return a;}
    constexpr modint &operator+=(const modint &rhs) noexcept{
        a+=rhs.a;
        if (a>=Modulus) a-=Modulus;
        return *this;
    }
    constexpr modint operator+(const modint &rhs) const noexcept{
        return modint(*this)+=rhs;
    }
    constexpr modint &operator++() noexcept{
        return ++a,*this;
    }
    constexpr modint operator++(int) noexcept{
        modint t=*this; return ++a,t;
    }
    constexpr modint &operator-=(const modint &rhs) noexcept{
        if (a<rhs.a) a+=Modulus;
        a-=rhs.a;
        return *this;
    }
    constexpr modint operator-(const modint &rhs) const noexcept{
        return modint(*this)-=rhs;
    }
    constexpr modint &operator--() noexcept{
        return --a,*this;
    }
    constexpr modint operator--(int) noexcept{
        modint t=*this; return --a,t;
    }
    constexpr modint &operator*=(const modint &rhs) noexcept{
        a=a*rhs.a%Modulus;
        return *this;
    }
    constexpr modint operator*(const modint &rhs) const noexcept{
        return modint(*this)*=rhs;
    }
    constexpr modint &operator/=(modint rhs) noexcept{
        u64 exp=Modulus-2;
        while(exp){
            if (exp&1) *this*=rhs;
            rhs*=rhs; exp>>=1;
        }
        return *this;
    }
    constexpr modint operator/(const modint &rhs) const noexcept{
        return modint(*this)/=rhs;
    }
    constexpr modint operator-() const noexcept{
        return modint(Modulus-a);
    }
    constexpr bool operator==(const modint &rhs) const noexcept{
        return a==rhs.a;
    }
    constexpr bool operator!=(const modint &rhs) const noexcept{
        return a!=rhs.a;
    }
    constexpr bool operator!() const noexcept{return !a;}
    friend constexpr modint pow(modint rhs,long long exp) noexcept{
        modint res{1};
        while(exp){
            if (exp&1) res*=rhs;
            rhs*=rhs; exp>>=1;
        }
        return res;
    }
    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;
    }
    friend ostream &operator<<(ostream &s,const modint &rhs) noexcept{
        return s << rhs.a;
    }
    friend istream &operator>>(istream &s,modint &rhs) noexcept{
        u64 a; rhs=modint{(s >> a,a)}; return s;
    }
};

template<int mod>
struct NumberTheoreticTransform{
    using Mint=modint<mod>;
    vector<Mint> roots;
    vector<int> rev;
    int base,max_base;
    Mint root;
    NumberTheoreticTransform():base(1),rev{0,1},roots{Mint(0),Mint(1)}{
        int tmp=mod-1;
        for (max_base=0;tmp%2==0;++max_base) tmp>>=1;
        root=2;
        while(pow(root,(mod-1)>>1)==1) ++root;
        root=pow(root,(mod-1)>>max_base);
    }
    void ensure_base(int nbase){
        if (nbase<=base) return;
        rev.resize(1<<nbase);
        for (int i=0;i<(1<<nbase);++i){
            rev[i]=(rev[i>>1]>>1)|((i&1)<<(nbase-1));
        }
        roots.resize(1<<nbase);
        for (;base<nbase;++base){
            Mint z=pow(root,1<<(max_base-1-base));
            for (int i=1<<(base-1);i<(1<<base);++i){
                roots[i<<1]=roots[i];
                roots[i<<1|1]=roots[i]*z;
            }
        }
    }
    void ntt(vector<Mint> &a){
        const int n=a.size();
        int zeros=__builtin_ctz(n);
        ensure_base(zeros);
        int shift=base-zeros;
        for (int i=0;i<n;++i){
            if (i<(rev[i]>>shift)){
                swap(a[i],a[rev[i]>>shift]);
            }
        }
        for (int k=1;k<n;k<<=1){
            for (int i=0;i<n;i+=(k<<1)){
                for (int j=0;j<k;++j){
                    Mint z=a[i+j+k]*roots[j+k];
                    a[i+j+k]=a[i+j]-z;
                    a[i+j]=a[i+j]+z;
                }
            }
        }
    }
    vector<Mint> multiply(vector<Mint> a,vector<Mint> b){
        int need=a.size()+b.size()-1;
        int nbase=1;
        while((1<<nbase)<need) ++nbase;
        ensure_base(nbase);
        int sz=1<<nbase;
        a.resize(sz,Mint(0)); b.resize(sz,Mint(0));
        ntt(a); ntt(b);
        Mint inv_sz=1/Mint(sz);
        for (int i=0;i<sz;++i) a[i]*=b[i]*inv_sz;
        reverse(a.begin()+1,a.end());
        ntt(a);
        a.resize(need);
        return a;
    }
    vector<int> multiply(vector<int> a,vector<int> b){
        vector<Mint> A(a.size()),B(b.size());
        for (int i=0;i<a.size();++i) A[i]=Mint(a[i]);
        for (int i=0;i<b.size();++i) B[i]=Mint(b[i]);
        vector<Mint> C=multiply(A,B);
        vector<int> res(C.size());
        for (int i=0;i<C.size();++i) res[i]=C[i].a;
        return res;
    }
};

template<typename M>
vector<M> ArbitaryModConvolution(const vector<M> &a,const vector<M> &b){
    int n=a.size(),m=b.size();
    static constexpr int mod0=167772161,mod1=469762049,mod2=754974721;
    using mint0=modint<mod0>;
    using mint1=modint<mod1>;
    using mint2=modint<mod2>;
    NumberTheoreticTransform<mod0> ntt0;
    NumberTheoreticTransform<mod1> ntt1;
    NumberTheoreticTransform<mod2> ntt2;
    vector<mint0> a0(n),b0(m);
    vector<mint1> a1(n),b1(m);
    vector<mint2> a2(n),b2(m);
    for (int i=0;i<n;++i) a0[i]=a[i].a,a1[i]=a[i].a,a2[i]=a[i].a;
    for (int i=0;i<m;++i) b0[i]=b[i].a,b1[i]=b[i].a,b2[i]=b[i].a;
    auto c0=ntt0.multiply(a0,b0);
    auto c1=ntt1.multiply(a1,b1);
    auto c2=ntt2.multiply(a2,b2);
    static const mint1 inv0=(mint1)1/mod0;
    static const mint2 inv1=(mint2)1/mod1,inv0inv1=inv1/mod0;
    static const M m0=mod0,m0m1=m0*mod1;
    vector<M> res(n+m-1);
    for (int i=0;i<n+m-1;++i){
        int v0=c0[i].a;
        int v1=(inv0*(c1[i]-v0)).a;
        int v2=(inv0inv1*(c2[i]-v0)-inv1*v1).a;
        res[i]=v0+m0*v1+m0m1*v2;
    }
    return res;
}

template<typename M>
struct FormalPowerSeries:vector<M>{
    using vector<M>::vector;
    using Poly=FormalPowerSeries;
    using MUL=function<Poly(Poly,Poly)>;
    static MUL &get_mul(){static MUL mul=nullptr; return mul;}
    static void set_mul(MUL f){get_mul()=f;}
    void shrink(){
        while(this->size()&&this->back()==M(0)) this->pop_back();
    }
    Poly pre(int deg) const {return Poly(this->begin(),this->begin()+min((int)this->size(),deg));}
    Poly operator+(const M &v) const {return Poly(*this)+=v;}
    Poly operator+(const Poly &p) const {return Poly(*this)+=p;}
    Poly operator-(const M &v) const {return Poly(*this)-=v;}
    Poly operator-(const Poly &p) const {return Poly(*this)-=p;}
    Poly operator*(const M &v) const {return Poly(*this)*=v;}
    Poly operator*(const Poly &p) const {return Poly(*this)*=p;}
    Poly operator/(const Poly &p) const {return Poly(*this)/=p;}
    Poly operator%(const Poly &p) const {return Poly(*this)%=p;}
    Poly &operator+=(const M &v){
        if (this->empty()) this->resize(1);
        (*this)[0]+=v;
        return *this;
    }
    Poly &operator+=(const Poly &p){
        if (p.size()>this->size()) this->resize(p.size());
        for (int i=0;i<p.size();++i) (*this)[i]+=p[i];
        return *this;
    }
    Poly &operator-=(const M &v){
        if (this->empty()) this->resize(1);
        (*this)[0]-=v;
        return *this;
    }
    Poly &operator-=(const Poly &p){
        if (p.size()>this->size()) this->resize(p.size());
        for (int i=0;i<p.size();++i) (*this)[i]-=p[i];
        return *this;
    }
    Poly &operator*=(const M &v){
        for (int i=0;i<this->size();++i) (*this)[i]*=v;
        return *this;
    }
    Poly &operator*=(const Poly &p){
        if (this->empty()||p.empty()){
            this->clear();
            return *this;
        }
        assert(get_mul()!=nullptr);
        return *this=get_mul()(*this,p);
    }
    Poly &operator/=(const Poly &p){
        if (this->size()<p.size()){
            this->clear();
            return *this;
        }
        int n=this->size()-p.size()-1;
        return *this=(rev().pre(n)*p.rev().inv(n)).pre(n).rev(n);
    }
    Poly &operator%=(const Poly &p){return *this-=*this/p*p;}
    Poly operator<<(const int deg){
        Poly res(*this);
        res.insert(res.begin(),deg,M(0));
        return res;
    }
    Poly operator>>(const int deg){
        if (this->size()<=deg) return {};
        Poly res(*this);
        res.erase(res.begin(),res.begin()+deg);
        return res;
    }
    Poly operator-() const {
        Poly res(this->size());
        for (int i=0;i<this->size();++i) res[i]=-(*this)[i];
        return res;
    }
    Poly rev(int deg=-1) const {
        Poly res(*this);
        if (~deg) res.resize(deg,M(0));
        reverse(res.begin(),res.end());
        return res;
    }
    Poly diff() const {
        Poly res(max(0,(int)this->size()-1));
        for (int i=1;i<this->size();++i) res[i-1]=(*this)[i]*M(i);
        return res;
    }
    Poly integral() const {
        Poly res(this->size()+1);
        res[0]=M(0);
        for (int i=0;i<this->size();++i) res[i+1]=(*this)[i]/M(i+1);
        return res;
    }
    Poly inv(int deg=-1) const {
        assert((*this)[0]!=M(0));
        if (deg<0) deg=this->size();
        Poly res({M(1)/(*this)[0]});
        for (int i=1;i<deg;i<<=1){
            res=(res+res-res*res*pre(i<<1)).pre(i<<1);
        }
        return res.pre(deg);
    }
    Poly log(int deg=-1) const {
        assert((*this)[0]==M(1));
        if (deg<0) deg=this->size();
        return (this->diff()*this->inv(deg)).pre(deg-1).integral();
    }
    Poly sqrt(int deg=-1) const {
        assert((*this)[0]==M(1));
        if (deg==-1) deg=this->size();
        Poly res({M(1)});
        M inv2=M(1)/M(2);
        for (int i=1;i<deg;i<<=1){
            res=(res+pre(i<<1)*res.inv(i<<1))*inv2;
        }
        return res.pre(deg);
    }
    Poly exp(int deg=-1){
        assert((*this)[0]==M(0));
        if (deg<0) deg=this->size();
        Poly res({M(1)});
        for (int i=1;i<deg;i<<=1){
            res=(res*(pre(i<<1)+M(1)-res.log(i<<1))).pre(i<<1);
        }
        return res.pre(deg);
    }
    Poly power(long long k,int deg=-1) const {
        if (deg<0) deg=this->size();
        for (int i=0;i<this->size();++i){
            if ((*this)[i]==M(0)) continue;
            if (k*i>deg) return Poly(deg,M(0));
            M inv=M(1)/(*this)[i];
            Poly res=(((*this*inv)>>i).log()*k).exp()*pow((*this)[i],k);
            res=(res<<(i*k)).pre(deg);
            if (res.size()<deg) res.resize(deg,M(0));
            return res;
        }
        return *this;
    }
    Poly pow_mod(long long k,const Poly &mod) const {
        Poly x(*this),res={M(1)};
        while (k>0){
            if (k&1) res=res*x%mod;
            x=x*x%mod; k>>=1;
        }
        return res;
    }
};

using mint=modint<MOD>;
using FPS=FormalPowerSeries<mint>;

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    auto mul=[&](const FPS::Poly &a,const FPS::Poly &b){
        auto res=ArbitaryModConvolution(a,b);
        return FPS::Poly(res.begin(),res.end());
    };
    FPS::set_mul(mul);

    int S; cin >> S;
    FPS a={1,MOD-1},b={1,MOD-1,0,MOD-1};
    FPS ans=a*b.inv(S+1);
    cout << ans[S] << '\n';
}

Measured memory_bytes: 3796