#include <bits/stdc++.h>
#define int long long
#define endl '\n'
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;

template <long long MOD> struct Fp {
    long long v;
    Fp(long long v = 0) : v(v % MOD) { if (v < 0) v += MOD; }
    long long get_mod() const { return MOD; }
    long long value() const { return v; }
    Fp operator - () const { return v ? MOD - v : 0; }
    Fp operator + (const Fp &r) const { return Fp(*this) += r; }
    Fp operator - (const Fp &r) const { return Fp(*this) -= r; }
    Fp operator * (const Fp &r) const { return Fp(*this) *= r; }
    Fp operator / (const Fp &r) const { return Fp(*this) /= r; }
    Fp& operator += (const Fp &r) { v += r.v; if (v >= MOD) v -= MOD; return *this; }
    Fp& operator -= (const Fp &r) { v -= r.v; if (v < 0) v += MOD; return *this; }
    Fp& operator *= (const Fp &r) { v = v * r.v % MOD; return *this; }
    Fp& operator /= (const Fp &r) { v = v * r.inv() % MOD; return *this; }
    bool operator == (const Fp &r) const { return this->v == r.v; }
    bool operator != (const Fp &r) const { return this->v != r.v; }
    friend ostream &operator << (ostream &os, const Fp<MOD> &x) { return os << x.v; }
    friend istream &operator >> (istream &is, Fp<MOD> &x) { return is >> x.v; }
    Fp<MOD> pow(long long n);
    Fp<MOD> inv();
};
using mint = Fp<1000000007>;

template <long long MOD> Fp<MOD> Fp<MOD>::pow(long long n) {
    Fp<MOD> res(1), tmp(v);
    while (n > 0) {
        if (n & 1) res *= tmp;
        tmp *= tmp;
        n >>= 1;
    }
    return res;
}

template <long long MOD> Fp<MOD> Fp<MOD>::inv() {
    long long a = v, b = MOD, x = 1, y = 0, t;
    while (b > 0) {
        t = a / b;
        swap(a -= t * b, b);
        swap(x -= t * y, y);
    }
    x %= MOD;
    if (x < 0) x += MOD;
    return x;
}

template <class T, size_t N> struct Mat {
    array<array<T, N>, N> A;
    Mat(T x = T(0)) { for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) A[i][j] = x; }
    inline const array<T, N>& operator [] (size_t i) const { return A[i]; }
    inline array<T, N>& operator [] (size_t i) { return A[i]; }
    Mat operator * (const Mat &B) const;
    Mat operator + (const Mat &B) const;
    Mat operator - (const Mat &B) const;
    Mat pow(long long n) const;
};

template <class T, size_t N> Mat<T, N> Mat<T, N>::operator * (const Mat &B) const {
    Mat C;
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) for (int k = 0; k < N; ++k) {
        C[i][j] = C[i][j] + (A[i][k] * B[k][j]);
    }
    return C;
}

template <class T, size_t N> Mat<T, N> Mat<T, N>::operator + (const Mat &B) const {
    Mat C;
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) {
        C[i][j] = A[i][j] + B[i][j];
    }
    return C;
}

template <class T, size_t N> Mat<T, N> Mat<T, N>::operator - (const Mat &B) const {
    Mat C;
    for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) {
        C[i][j] = A[i][j] - B[i][j];
    }
    return C;
}

template <class T, size_t N> Mat<T, N> Mat<T, N>::pow(long long n) const {
    Mat B = *this, res;
    for (int i = 0; i < N; ++i) res[i][i] = 1;
    while (n) {
        if (n & 1) res = res * B;
        B = B * B;
        n >>= 1;
    }
    return res;
}

void _main() {
    int N;
    cin >> N;
    Mat<mint, 6> A;
    REP (i, 6) A[0][i] = mint(6).inv();
    REP (i, 5) A[i + 1][i] = mint(1);
    cout << A.pow(N)[0][0] << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(10);
    _main();
    return 0;
}