#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n) - 1; i >= 0; i--)
#define rep2(i, l, r) for (int i = (l); i < (r); i++)
#define rep2r(i, l, r) for (int i = (r) - 1; i >= (l); i--)
#define range(a) a.begin(), a.end()

using namespace std;
using ll = long long;

constexpr int MOD = 1000000007;

class mint {
  int n;
public:
  mint(int n_ = 0) : n(n_) {}
  explicit operator int() { return n; }
  friend mint operator-(mint a) { return -a.n + MOD * (a.n != 0); }
  friend mint operator+(mint a, mint b) { int x = a.n + b.n; return x - (x >= MOD) * MOD; }
  friend mint operator-(mint a, mint b) { int x = a.n - b.n; return x + (x < 0) * MOD; }
  friend mint operator*(mint a, mint b) { return (long long)a.n * b.n % MOD; }
  friend mint &operator+=(mint &a, mint b) { return a = a + b; }
  friend mint &operator-=(mint &a, mint b) { return a = a - b; }
  friend mint &operator*=(mint &a, mint b) { return a = a * b; }
  friend bool operator==(mint a, mint b) { return a.n == b.n; }
  friend bool operator!=(mint a, mint b) { return a.n != b.n; }
  friend istream &operator>>(istream &i, mint &a) { return i >> a.n; }
  friend ostream &operator<<(ostream &o, mint a) { return o << a.n; }
};
mint operator "" _m(unsigned long long n) { return n; }

mint modinv(mint n) {
  int a = (int)n, b = MOD;
  int s = 1, t = 0;
  while (b != 0) {
    int q = a / b;
    a -= q * b;
    s -= q * t;
    swap(a, b);
    swap(s, t);
  }
  return s >= 0 ? s : s + MOD;
}


vector<mint> berlekamp_massey(vector<mint> s) {
  const int N = s.size();
  vector<mint> C(N);
  vector<mint> B(N);
  C[0] = 1;
  B[0] = 1;
  int L = 0;
  int m = 1;
  mint b = 1;
  for (int n = 0; n < N; n++) {
    mint d = s[n];
    for (int i = 1; i <= L; i++) d += C[i] * s[n - i];
    mint inv_b = modinv(b);
    if (d == 0) {
      m++;
    } else if (2 * L <= n) {
      auto T = C;
      for (int i = 0; i + m < N; i++) C[i + m] -= B[i] * d * inv_b;
      L = n + 1 - L;
      B = T;
      b = d;
      m = 1;
    } else {
      for (int i = 0; i + m < N; i++) C[i + m] -= B[i] * d * inv_b;
      m++;
    }
  }
  C.resize(L + 1);
  reverse(C.begin(), C.end());
  assert(L < N - 1);
  C.pop_back();
  for (int i = 0; i < C.size(); i++) {
    C[i] = -C[i];
  }
  return C;
}

vector<mint> poly_mod(vector<mint> a, const vector<mint> &m) {
  const int n = m.size();
  for (int i = a.size() - 1; i >= m.size(); i--) {
    for (int j = 0; j < m.size(); j++) {
      a[i - n + j] += a[i] * m[j];
    }
  }
  a.resize(m.size());
  return a;
}

// a*b mod m(x)
vector<mint> poly_mul(const vector<mint> &a, const vector<mint> &b, const vector<mint> &m) {
  vector<mint> ret(a.size() + b.size() - 1);
  for (int i = 0; i < a.size(); i++) {
    for (int j = 0; j < b.size(); j++) {
      ret[i + j] += a[i] * b[j];
    }
  }
  return poly_mod(ret, m);
}

// x^n mod m(x)
vector<mint> nth_power(long long n, const vector<mint> &m) {
  vector<mint> ret(1);
  vector<mint> x(2);
  ret[0] = x[1] = 1;
  while (n > 0) {
    if (n & 1) ret = poly_mul(ret, x, m);
    x = poly_mul(x, x, m);
    n /= 2;
  }
  return poly_mod(ret, m);
}

mint predict_nth(vector<mint> a, long long n) {
  auto b = nth_power(n, berlekamp_massey(a));
  mint res = 0;
  for (int i = 0; i < b.size(); i++) {
    res += a[i] * b[i];
  }
  return res;
}

/*
1/(1-x)(1-x^2)(1-x^3) = 1 + x + 2 x  + 3 x  + 4 x  + 5 x  + 7 x  + 8 x  + 10 x  + 12 x
       10       11       12       13       14       15       16       17
 + 14 x   + 16 x   + 19 x   + 21 x   + 24 x   + 27 x   + 30 x   + 33 x
       18       19       20
 + 37 x   + 40 x   + 44 x 
*/

int main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(15);
  vector<mint> p{0,0,0,0,1,1,2,3,4,5,7,8,10,12,14,16};
  ll n; cin >> n;
  cout << predict_nth(p, n) << endl;
}