// Slower C++ solution:
// #include <atcoder/all>

// using namespace atcoder;

#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (int)n; ++i)

#define rrep(i, n) for (int i = (int)n-1; i >= 0; --i)

using namespace std;

using ll = long long;

template<typename T>

inline bool chmax(T& a, const T& b) {

    if (a < b){

        a = b;

        return true;

    }

    return false;

}

template<typename T>

inline bool chmin(T& a, const T& b) {

    if (b < a) {

        a = b;

        return true;

    }

    return false;

}

/**

 * @brief 多次元 vector の作成

 * @author えびちゃん

 */

namespace detail {

    template<typename T, int N>

    auto make_vec(vector<int>& sizes, T const& x) {

        if constexpr (N == 1) {

            return vector(sizes[0], x);

        } else {

            int size = sizes[N-1];

            sizes.pop_back();

            return vector(size, make_vec<T, N-1>(sizes, x));

        }

    }

}

template<typename T, int N>

auto make_vec(int const(&sizes)[N], T const& x = T()) {

    vector<int> s(N);

    for (int i = 0; i < N; ++i) s[i] = sizes[N-i-1];

    return detail::make_vec<T, N>(s, x);

}

__attribute__((constructor))

void fast_io() {

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

}



template<uint_fast64_t Modulus>

struct modint {

    using u64 = uint_fast64_t;

    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) 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 {

        a += rhs.a;

        if (a >= Modulus) a -= Modulus;

        return *this;

    }

    constexpr modint& operator-=(const modint rhs) noexcept {

        if (a < rhs.a) a += Modulus;

        a -= rhs.a;

        return *this;

    }

    constexpr modint& operator*=(const modint rhs) noexcept {

        a = a * rhs.a % Modulus;

        return *this;

    }

    constexpr modint& operator/=(modint rhs) noexcept {

        return *this *= rhs.inv();

    }

    constexpr modint& operator++() noexcept {

        a++;

        if (a == Modulus) a = 0;

        return *this;

    }

    constexpr modint operator++(int) noexcept {

        modint tmp(*this);

        operator++();

        return tmp;

    }

    constexpr modint& operator--() noexcept {

        if (a == 0) a = Modulus;

        a--;

        return *this;

    }

    constexpr modint operator--(int) noexcept {

        modint tmp(*this);

        operator--();

        return tmp;

    }

    constexpr modint pow(u64 exp) const noexcept {

        modint res(1), mul(*this);

        for (; exp; mul *= mul, exp >>= 1) if (exp & 1) res *= mul;

        return res;

    }

    constexpr modint inv() const noexcept {

        return modint(*this).pow(Modulus - 2);

    }

    constexpr bool operator==(modint rhs) const noexcept { return a == rhs.a; }

    constexpr bool operator!=(modint rhs) const noexcept { return a != rhs.a; }

    friend ostream& operator<<(ostream& os, const modint<Modulus>& rhs) { return os << rhs.a; }

};



using mint = modint<1000000007>;



vector<mint> fact, ifact;

void init(int n) {

    fact.resize(n+1);

    ifact.resize(n+1);

    fact[0] = 1;

    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1] * i;

    ifact[n] = fact[n].inv();

    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i] * i;

}

mint comb(int n, int k) { return fact[n] * ifact[k] * ifact[n-k]; }

mint perm(int n, int k) { return fact[n] * ifact[n-k]; }



int main() {

    int s;

    cin >> s;

    int mx = s / 3;

    mint ans = 0;

    init(1e5);

    for (int i = 1; i <= mx; ++i) {

        int sum = s - 3 * i;

        ans += comb(sum + i - 1, i - 1);

    }

    cout << ans << '\n';

}

// Faster C++ solution for the same problem (measured speedup: 3.5981344444711922x):
// #include <atcoder/all>

// using namespace atcoder;

#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (int)n; ++i)

#define rrep(i, n) for (int i = (int)n-1; i >= 0; --i)

using namespace std;

using ll = long long;

template<typename T>

inline bool chmax(T& a, const T& b) {

    if (a < b){

        a = b;

        return true;

    }

    return false;

}

template<typename T>

inline bool chmin(T& a, const T& b) {

    if (b < a) {

        a = b;

        return true;

    }

    return false;

}

/**

 * @brief 多次元 vector の作成

 * @author えびちゃん

 */

namespace detail {

    template<typename T, int N>

    auto make_vec(vector<int>& sizes, T const& x) {

        if constexpr (N == 1) {

            return vector(sizes[0], x);

        } else {

            int size = sizes[N-1];

            sizes.pop_back();

            return vector(size, make_vec<T, N-1>(sizes, x));

        }

    }

}

template<typename T, int N>

auto make_vec(int const(&sizes)[N], T const& x = T()) {

    vector<int> s(N);

    for (int i = 0; i < N; ++i) s[i] = sizes[N-i-1];

    return detail::make_vec<T, N>(s, x);

}

__attribute__((constructor))

void fast_io() {

    ios::sync_with_stdio(false);

    cin.tie(nullptr);

}



template<uint_fast64_t Modulus>

struct modint {

    using u64 = uint_fast64_t;

    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) 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 {

        a += rhs.a;

        if (a >= Modulus) a -= Modulus;

        return *this;

    }

    constexpr modint& operator-=(const modint rhs) noexcept {

        if (a < rhs.a) a += Modulus;

        a -= rhs.a;

        return *this;

    }

    constexpr modint& operator*=(const modint rhs) noexcept {

        a = a * rhs.a % Modulus;

        return *this;

    }

    constexpr modint& operator/=(modint rhs) noexcept {

        return *this *= rhs.inv();

    }

    constexpr modint& operator++() noexcept {

        a++;

        if (a == Modulus) a = 0;

        return *this;

    }

    constexpr modint operator++(int) noexcept {

        modint tmp(*this);

        operator++();

        return tmp;

    }

    constexpr modint& operator--() noexcept {

        if (a == 0) a = Modulus;

        a--;

        return *this;

    }

    constexpr modint operator--(int) noexcept {

        modint tmp(*this);

        operator--();

        return tmp;

    }

    constexpr modint pow(u64 exp) const noexcept {

        modint res(1), mul(*this);

        for (; exp; mul *= mul, exp >>= 1) if (exp & 1) res *= mul;

        return res;

    }

    constexpr modint inv() const noexcept {

        return modint(*this).pow(Modulus - 2);

    }

    constexpr bool operator==(modint rhs) const noexcept { return a == rhs.a; }

    constexpr bool operator!=(modint rhs) const noexcept { return a != rhs.a; }

    friend ostream& operator<<(ostream& os, const modint<Modulus>& rhs) { return os << rhs.a; }

};



using mint = modint<1000000007>;



int main() {

    int s;

    cin >> s;

    vector<mint> dp(s+1);

    dp[0] = 1;

    for (int i = 1; i <= s; ++i) {

        for (int j = 3; i-j >= 0; ++j) {

            dp[i] += dp[i-j];

        }

    }

    cout << dp[s] << '\n';

}