#include<bits/stdc++.h>
using namespace std;
#define int long long

const unsigned int MOD = 1e9 + 7;

int n;
int dp[114514];


template <typename _Tp> class Matrix
{
    size_t n, m;
    _Tp MOD;

  public:
    inline size_t r()
    {
        return n;
    };
    inline size_t c()
    {
        return m;
    };
    const inline size_t r() const
    {
        return n;
    };
    const inline size_t c() const
    {
        return m;
    };

    vector<vector<_Tp>> a;
    Matrix(size_t r, size_t c) : n(r), m(c)
    {
        MOD = numeric_limits<_Tp>::max();
        a = vector<vector<_Tp>>(n, vector<_Tp>(m));
    }
    Matrix(size_t r, size_t c, _Tp x) : n(r), m(c), MOD(x)
    {
        a = vector<vector<_Tp>>(n, vector<_Tp>(m));
    }
    Matrix(vector<vector<_Tp>> A) : a(A), n(A.size()), m(A[0].size())
    {
        n = A.size(), m = A[0].size();
        MOD = numeric_limits<_Tp>::max();
    }
    Matrix(vector<vector<_Tp>> A, _Tp x) : a(A), MOD(x)
    {
        n = A.size(), m = A[0].size();
    }

    const vector<_Tp> &operator[](size_t i) const
    {
        return a[i];
    }

    vector<_Tp> &operator[](size_t i)
    {
        return a[i];
    }

    Matrix operator*(const Matrix &b) const
    {
        if (m != b.r())
        {
            return Matrix<_Tp>(0, 0, MOD);
        }
        Matrix<_Tp> c(n, b.m, MOD);
        for (size_t i = 0; i < n; ++i)
        {
            for (size_t j = 0; j < b.c(); ++j)
            {
                for (size_t k = 0; k < m; ++k)
                {
                    c[i][j] = (c[i][j] + a[i][k] * b[k][j] % MOD) % MOD;
                }
            }
        }
        return c;
    }

    Matrix operator^(long long k)
    {
        Matrix<_Tp> ret(n, n, MOD);
        for (size_t i = 0; i < n; ++i)
        {
            ret[i][i] = 1;
        }
        for (Matrix<_Tp> A = *this; k; A = A * A, k >>= 1)
        {
            if (k & 1)
                ret = ret * A;
        }
        return ret;
    }
};

int solve_small()
{
    if (n == 1)
    {
        return 2;
    }
    if (n == 2)
    {
        return 4;
    }
    dp[1] = 3;
    dp[2] = 5;
    for (int i = 3; i <= n; ++i)
    {
        dp[i] = dp[i - 2] * 5 % MOD;
    }

    return dp[n - 2] * 4 % MOD;
}

int solve()
{
    if (n == 1)
    {
        return 2;
    }
    if (n == 2)
    {
        return 4;
    }
    Matrix<int> A({{0, 0, 5}, {1, 0, 0}, {0, 1, 0}}, MOD), b({{5, 3, 0}}, MOD); //dp[i], dp[i - 1], dp[i - 2]
    Matrix<int> res = b * (A ^ (n - 2));
    return res[0][0] * 4 % MOD;
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    if (n <= 100000)
    {
        cout << solve_small();
        return 0;
    }
    cout << solve();
}