//
//
//
// Created by Evgeny Savinov on 09/01/2017.
//

#include <bits/stdc++.h>

#define clr(x) memset((x), 0, sizeof(x))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define x first
#define y second
#define forn(i, n) for(int i = 0; i < (int)(n); ++i)
#define ford(i, n) for(int i = (int)(n) - 1; i >= 0; --i)
#define for1(i, n) for(int i = 1; i <= (int)(n); ++i)


using namespace std;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
//typedef pair<long long, long long> pii;
typedef vector<long long> vll;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;

const ld PI = 3.1415926535897932384626433832795L;

template<class T>
bool uin(T &, const T &);

template<class T>
bool uax(T &, const T &);

template<class T>
T gcd(T, T);

template<class T>
T lcm(T, T);

template<class _T>
inline string tostr(const _T &);

template<typename T>
void input(T &);

class range {
    using type = long long;
public:
    class iterator {
        friend class range;

    public:
        using difference_type = range::type;
        using value_type = range::type;
        using pointer = const range::type *;
        using reference = const range::type &;
        using iterator_category = std::random_access_iterator_tag;

        value_type operator*() const { return i_; }

        const iterator &operator++() {
            ++i_;
            return *this;
        }

        iterator operator++(int) {
            iterator copy(*this);
            ++i_;
            return copy;
        }

        const iterator &operator--() {
            --i_;
            return *this;
        }

        iterator operator--(int) {
            iterator copy(*this);
            --i_;
            return copy;
        }

        difference_type operator-(const iterator &other) const { return i_ - other.i_; }

        iterator operator+(const difference_type &delta) const { return iterator(i_ + delta); }

        iterator &operator+=(const difference_type &delta) {
            i_ += delta;
            return *this;
        }

        iterator operator-(const difference_type &delta) const { return iterator(i_ - delta); }

        iterator &operator-=(const difference_type &delta) {
            i_ -= delta;
            return *this;
        }

        bool operator==(const iterator &other) const { return i_ == other.i_; }

        bool operator!=(const iterator &other) const { return i_ != other.i_; }

    protected:
        iterator(const value_type &start) : i_(start) {}

    private:
        value_type i_;
    };

    iterator begin() const { return begin_; }

    iterator end() const { return end_; }

    range(const type &begin, const type &end) : begin_(begin), end_(end) {}

    range(const type &end) : begin_(0), end_(end) {}

private:
    iterator begin_;
    iterator end_;
};

template<typename T = long long>
T nxt();

bool checkp(long long);

template<typename T>
T pw(T a, T n, T p);

template<typename T>
T inv(T a, T p);

template<class _T>
_T sqr(const _T &x);

class range;

static mt19937_64 gen;

static int TTT;

const ll mod = 1000000007;

void pre() {
}


int x[1000];

int n;

int ans;

void rec(int pos) {
    if (pos == -1) {
//        forn(i, n) {
//            cerr << x[i] << " ";
//        }
//        cerr << "\n";
        ++ans;
        return;
    }
    if (pos == n - 1) {
        for (int t = 1; t <= n; ++t) {
            forn(j, n + 1) x[n - 1 + j] = t;
            rec(pos - 1);
        }
    } else {
        int t = x[pos + 1];
        int m = 1;
        for (int k = 2; k <= n; ++k) {
            if (x[pos + k] != t) break;
            m = k;
        }
        for (int t = 1; t <= m; ++t) {
            x[pos] = t;
            rec(pos - 1);
        }
    }
}

vll norm(vll a, vll md) {
    for (int i = (int)a.size() - 1; i >= (int)md.size() - 1; --i) {
        ll t = a[i];
        for (int j = 0; j < md.size(); ++j) {
            a[i - md.size() + j + 1] -= t * md[j];
            a[i - md.size() + j + 1] %= mod;
        }
        assert(a[i] == 0);
    }

    a.resize(md.size() - 1);
    return a;
}

vll mul(vll a, vll b, vll md) {
    vll res(a.size() + b.size() - 1);
    forn(i, a.size()) forn(j, b.size()) {
            res[i + j] += a[i] * b[j];
            res[i + j] %= mod;
        }
//    return res;
    return norm(res, md);
}



void solve(int test) {
    //printf("Case #%d: ", test);




    int n = nxt() - 1;
//    ::n = n + 1;
//    rec(::n - 1);
//    cerr << ans << "\n";

    vll M = {1, -4, 12, -25, 40, -51, 50, -38, 21, -7, 1};
    vll st = {1, 4, 15, 43, 117, 306, 745, 1716, 3825, 8326, 17751, 37181, 76753, 156521, 315855, 631576, 1252785, 2467449, 4829239};


    vll x(M.size() - 1);

    vll a(2);
    a[1] = 1;

    x[0] = 1;
    while (n) {
        if (n & 1) x = mul(x, a, M);
        a = mul(a, a, M);
        n >>= 1;
    }

//    forn(i, x.size()) {
//        cerr << i << " " << x[i] << "\n";
//    }

    ll ans = 0;

    forn(i, a.size()) {
        ans += x[i] * st[i];
        ans %= mod;
    }

    if (ans < 0) ans += mod;

    cout << ans << "\n";

}

int main(int argc, char **argv) {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#else
    #define fname "sequence"
    //freopen(fname".in", "r", stdin);
    //freopen(fname".out", "w", stdout);
#endif
    pre();
    ::TTT = 1;
#ifdef LOCAL
#else
#endif

    for (int test = 1; test <= ::TTT; ++test) {
        solve(test);
    }

#ifdef LOCAL
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif
    return 0;
}


template<typename T>
T gcd(T x, T y) {
    while (y > 0) {
        x %= y;
        swap(x, y);
    }
    return x;
}

template<class T>
T lcm(T a, T b) {
    return a / gcd(a, b) * b;
}


template<class _T>
inline _T sqr(const _T &x) {
    return x * x;
}

template<class _T>
inline string tostr(const _T &a) {
    ostringstream os("");
    os << a;
    return os.str();
}


template<typename T>
inline void input(T &a) {
    int ed;
    a = 0;
    while (!isdigit(ed = getchar()) && ed != '-') {}
    char neg = 0;
    if (ed == '-') {
        neg = 1;
        ed = getchar();
    }
    while (isdigit(ed)) {
        a = 10 * a + ed - '0';
        ed = getchar();
    }
    if (neg) a = -a;
}

template<typename T = long long>
inline T nxt() {
    T res;
    input(res);
    return res;
}

void myassert(bool v) {
    assert(v);
//cout << "FAIL\n";
//exit(0);
}

mt19937 generator;

bool checkp(long long v) {
    if (v < 2) return false;
    for (long long i = 2; i * i <= v; ++i) {
        if (v % i == 0) {
            return false;
        }
    }
    return true;
}

template<typename T>
T pw(T a, T n, T m) {
    T res = 1;
    while (n) {
        if (n & 1) {
            res = res * a % m;
        }
        a = a * a % m;
        n >>= 1;
    }
    return res;
}

template<typename T>
T inv(T a, T p) {
    T res = 1;
    while (a > 1) {
        res = res * (p - p / a) % p;
        a = p % a;
    }
    return res;
}


template<class T>
bool uin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool uax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}


Measured memory_bytes: 256