// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
using namespace std;

/********************************************************************/
#define M1 1000000007
#define M3 1000000009
#define M2 998244353
#define ll long long
#define ld long double
#define pll pair<ll,ll>
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define repr(i,a,b) for(ll i=b-1;i>=a;i--)
#define forr(i,n) for(ll i=0;i<n;i++)
#define F first
#define S second
#define pb push_back
#define DB pop_back
#define mp make_pair
#define MT make_tuple
#define V(a) vector<a>
#define vi vector<ll>
#define endl '\n'
#define ce(ele) cout<<ele<<' '
#define cs(ele) cout<<ele<<'\n'
#define yep cout<<"YES"<<'\n'
#define nope cout<<"NO"<<'\n'
#define CASE(te) ll te; cin>>te; while(te--)
#define sor(v) sort(v.begin(),v.end())
#define rev(v) reverse(v.begin(),v.end())

/********************************************************************/
const double pi = 3.1415926535;
//const int mx = 69;
//char grid[mx][mx];
// ll blocked[mx][mx];
// ll vis[mx][mx];
/********************************************************************/
//FAST IO//
void FAST() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
}

/********************************************************************/

ll power(ll x,ll y,ll p) 
{ 
    ll res = 1; 
    x = x % p; 
    while (y > 0) 
    {  
        if (y & 1) 
         res = (res * x) % p; 
        y = y >> 1; 
        x = (x * x) % p; 
    } 
    return res; 
} 

bool isprime(ll n) 
{ 
    if (n <= 1) 
        return false; 
    if (n <= 3) 
        return true; 
    if (n % 2 == 0 || n % 3 == 0) 
        return false; 
    for (ll i = 5; i * i <= n; i = i + 6) 
        if (n % i == 0 || n % (i + 2) == 0) 
            return false; 
    return true; 
} 
  

vector<ll> digit(ll n)
{
    ll arr[10000];
    ll i=0;
    ll j,r;
    vi v;
    while(n!=0)
    {
        r = n % 10;
        arr[i] = r;
        i++;
        n = n / 10;
    }
    for(j=i-1;j>-1;j--)
    {
        v.pb(arr[j]);
    }
    return v;
}

ll sum(ll x) {
	ll ans = 0;
	while (x > 0) {
		ans += (x % 10);
		x /= 10;
	}
	return ans;
}

bool opp(int x, int y)
{
    return ((x ^ y) < 0);
}

bool bysec(const pair<int,int> &a, const pair<int,int> &b) 
{ 
    return (a.second < b.second); 
}


void findCombinationsUtil(int arr[], int index, 
                       int num, int reducedNum) 
{ 
    // Base condition 
    if (reducedNum < 0) 
        return; 
  
    // If combination is found, print it 
    if (reducedNum == 0) 
    { 
        for (int i = 0; i < index; i++) 
            cout << arr[i] << " "; 
        cout << endl; 
        return; 
    } 
  
    // Find the previous number stored in arr[] 
    // It helps in maintaining increasing order 
    int prev = (index == 0)? 1 : arr[index-1]; 
  
    // note loop starts from previous number 
    // i.e. at array location index - 1 
    for (int k = prev; k <= num ; k++) 
    { 
        // next element of array is k 
        arr[index] = k; 
  
        // call recursively with reduced number 
        findCombinationsUtil(arr, index + 1, num, 
                                 reducedNum - k); 
    } 
} 
  
/* Function to find out all combinations of 
   positive numbers that add upto given number. 
   It uses findCombinationsUtil() */
void findCombinations(int n) 
{ 
    // array to store the combinations 
    // It can contain max n elements 
    int arr[n]; 
  
    //find all combinations 
    findCombinationsUtil(arr, 0, n, n); 
} 

int main()
{
  FAST();
  ll n;
  cin>>n;
  ll dp[n+5]={0};
  dp[1]=0;
  dp[2]=0;
  dp[3]=1;
  dp[4]=1;
  dp[5]=1;
  for(int i=6;i<=n;i++)
  {
      for(int j=1;i-j>=3;j++)
      {
          dp[i]+=dp[j];
          dp[i]%=M1;
      }
      dp[i]++;
      dp[i]%=M1;
  }
  cs((dp[n])%M1);
}


Measured memory_bytes: 3644