#include "bits/stdc++.h"

using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define FORL(i,a,b) for(LL i=(a);i<(b);++i)
#define REPL(i,n)  FORL(i,0,n)
#define ALL(a) (a).begin(),(a).end()

#define MOD 1000000007

int main(void) {
    LL n;
    cin >> n;
    if(n == 1) {
        cout << 4 << endl;
        return 0;
    }
    if(n == 2) {
        cout << 16 << endl;
        return 0;
    }
    vector<VVVLL> dp(n, VVVLL(4, VVLL(4, VLL(4, 1)))); //0A 1C 2G 3T
    dp[2][0][2][1] = 0;
    dp[2][0][1][2] = 0;
    dp[2][2][0][1] = 0;
    FOR(i, 3, n) {
        //                         A                  C                  G                  T
        dp[i][0][0][0] = (dp[i-1][0][0][0] + dp[i-1][1][0][0] + dp[i-1][2][0][0] + dp[i-1][3][0][0]) % MOD; //AAA
        dp[i][0][0][1] = (dp[i-1][0][0][0] + dp[i-1][1][0][0] + dp[i-1][2][0][0] + dp[i-1][3][0][0]) % MOD; //AAC
        dp[i][0][0][2] = (dp[i-1][0][0][0] + dp[i-1][1][0][0] + dp[i-1][2][0][0] + dp[i-1][3][0][0]) % MOD; //AAG
        dp[i][0][0][3] = (dp[i-1][0][0][0] + dp[i-1][1][0][0] + dp[i-1][2][0][0] + dp[i-1][3][0][0]) % MOD; //AAT

        dp[i][0][1][0] = (dp[i-1][0][0][1] + dp[i-1][1][0][1] + dp[i-1][2][0][1] + dp[i-1][3][0][1]) % MOD; //ACA
        dp[i][0][1][1] = (dp[i-1][0][0][1] + dp[i-1][1][0][1] + dp[i-1][2][0][1] + dp[i-1][3][0][1]) % MOD; //ACC
        dp[i][0][1][2] = 0                                                                                ; //ACG
        dp[i][0][1][3] = (dp[i-1][0][0][1] + dp[i-1][1][0][1] + dp[i-1][2][0][1] + dp[i-1][3][0][1]) % MOD; //ACT

        dp[i][0][2][0] = (dp[i-1][0][0][2] + dp[i-1][1][0][2] + dp[i-1][2][0][2] + dp[i-1][3][0][2]) % MOD; //AGA
        dp[i][0][2][1] = 0                                                                                ; //AGC
        dp[i][0][2][2] = (dp[i-1][0][0][2] + dp[i-1][1][0][2] + dp[i-1][2][0][2] + dp[i-1][3][0][2]) % MOD; //AGG
        dp[i][0][2][3] = (dp[i-1][0][0][2] + dp[i-1][1][0][2] + dp[i-1][2][0][2] + dp[i-1][3][0][2]) % MOD; //AGT

        dp[i][0][3][0] = (dp[i-1][0][0][3] + dp[i-1][1][0][3] + dp[i-1][2][0][3] + dp[i-1][3][0][3]) % MOD; //ATA
        dp[i][0][3][1] = (dp[i-1][0][0][3] + dp[i-1][1][0][3] + dp[i-1][2][0][3] + dp[i-1][3][0][3]) % MOD; //ATC
        dp[i][0][3][2] = (dp[i-1][0][0][3] + dp[i-1][1][0][3] + dp[i-1][2][0][3] + dp[i-1][3][0][3]) % MOD; //ATG
        dp[i][0][3][3] = (dp[i-1][0][0][3] + dp[i-1][1][0][3] + dp[i-1][2][0][3] + dp[i-1][3][0][3]) % MOD; //ATT

        //                         A                  C                  G                  T
        dp[i][1][0][0] = (dp[i-1][0][1][0] + dp[i-1][1][1][0] + dp[i-1][2][1][0] + dp[i-1][3][1][0]) % MOD; //CAA
        dp[i][1][0][1] = (dp[i-1][0][1][0] + dp[i-1][1][1][0] + dp[i-1][2][1][0] + dp[i-1][3][1][0]) % MOD; //CAC
        dp[i][1][0][2] = (dp[i-1][0][1][0] + dp[i-1][1][1][0] + dp[i-1][2][1][0] + dp[i-1][3][1][0]) % MOD; //CAG
        dp[i][1][0][3] = (dp[i-1][0][1][0] + dp[i-1][1][1][0] + dp[i-1][2][1][0] + dp[i-1][3][1][0]) % MOD; //CAT

        dp[i][1][1][0] = (dp[i-1][0][1][1] + dp[i-1][1][1][1] + dp[i-1][2][1][1] + dp[i-1][3][1][1]) % MOD; //CCA
        dp[i][1][1][1] = (dp[i-1][0][1][1] + dp[i-1][1][1][1] + dp[i-1][2][1][1] + dp[i-1][3][1][1]) % MOD; //CCC
        dp[i][1][1][2] = (dp[i-1][0][1][1] + dp[i-1][1][1][1] + dp[i-1][2][1][1] + dp[i-1][3][1][1]) % MOD; //CCG
        dp[i][1][1][3] = (dp[i-1][0][1][1] + dp[i-1][1][1][1] + dp[i-1][2][1][1] + dp[i-1][3][1][1]) % MOD; //CCT

        dp[i][1][2][0] = (dp[i-1][0][1][2] + dp[i-1][1][1][2] + dp[i-1][2][1][2] + dp[i-1][3][1][2]) % MOD; //CGA
        dp[i][1][2][1] = (                   dp[i-1][1][1][2] + dp[i-1][2][1][2] + dp[i-1][3][1][2]) % MOD; //CGC
        dp[i][1][2][2] = (dp[i-1][0][1][2] + dp[i-1][1][1][2] + dp[i-1][2][1][2] + dp[i-1][3][1][2]) % MOD; //CGG
        dp[i][1][2][3] = (dp[i-1][0][1][2] + dp[i-1][1][1][2] + dp[i-1][2][1][2] + dp[i-1][3][1][2]) % MOD; //CGT

        dp[i][1][3][0] = (dp[i-1][0][1][3] + dp[i-1][1][1][3] + dp[i-1][2][1][3] + dp[i-1][3][1][3]) % MOD; //CTA
        dp[i][1][3][1] = (dp[i-1][0][1][3] + dp[i-1][1][1][3] + dp[i-1][2][1][3] + dp[i-1][3][1][3]) % MOD; //CTC
        dp[i][1][3][2] = (dp[i-1][0][1][3] + dp[i-1][1][1][3] + dp[i-1][2][1][3] + dp[i-1][3][1][3]) % MOD; //CTG
        dp[i][1][3][3] = (dp[i-1][0][1][3] + dp[i-1][1][1][3] + dp[i-1][2][1][3] + dp[i-1][3][1][3]) % MOD; //CTT

        //                         A                  C                  G                  T
        dp[i][2][0][0] = (dp[i-1][0][2][0] + dp[i-1][1][2][0] + dp[i-1][2][2][0] + dp[i-1][3][2][0]) % MOD; //GAA
        dp[i][2][0][1] = 0                                                                                ; //GAC
        dp[i][2][0][2] = (dp[i-1][0][2][0] + dp[i-1][1][2][0] + dp[i-1][2][2][0] + dp[i-1][3][2][0]) % MOD; //GAG
        dp[i][2][0][3] = (dp[i-1][0][2][0] + dp[i-1][1][2][0] + dp[i-1][2][2][0] + dp[i-1][3][2][0]) % MOD; //GAT

        dp[i][2][1][0] = (dp[i-1][0][2][1] + dp[i-1][1][2][1] + dp[i-1][2][2][1] + dp[i-1][3][2][1]) % MOD; //GCA
        dp[i][2][1][1] = (                   dp[i-1][1][2][1] + dp[i-1][2][2][1] + dp[i-1][3][2][1]) % MOD; //GCC
        dp[i][2][1][2] = (dp[i-1][0][2][1] + dp[i-1][1][2][1] + dp[i-1][2][2][1] + dp[i-1][3][2][1]) % MOD; //GCG
        dp[i][2][1][3] = (dp[i-1][0][2][1] + dp[i-1][1][2][1] + dp[i-1][2][2][1] + dp[i-1][3][2][1]) % MOD; //GCT

        dp[i][2][2][0] = (dp[i-1][0][2][2] + dp[i-1][1][2][2] + dp[i-1][2][2][2] + dp[i-1][3][2][2]) % MOD; //GGA
        dp[i][2][2][1] = (                   dp[i-1][1][2][2] + dp[i-1][2][2][2] + dp[i-1][3][2][2]) % MOD; //GGC
        dp[i][2][2][2] = (dp[i-1][0][2][2] + dp[i-1][1][2][2] + dp[i-1][2][2][2] + dp[i-1][3][2][2]) % MOD; //GGG
        dp[i][2][2][3] = (dp[i-1][0][2][2] + dp[i-1][1][2][2] + dp[i-1][2][2][2] + dp[i-1][3][2][2]) % MOD; //GGT

        dp[i][2][3][0] = (dp[i-1][0][2][3] + dp[i-1][1][2][3] + dp[i-1][2][2][3] + dp[i-1][3][2][3]) % MOD; //GTA
        dp[i][2][3][1] = (                   dp[i-1][1][2][3] + dp[i-1][2][2][3] + dp[i-1][3][2][3]) % MOD; //GTC
        dp[i][2][3][2] = (dp[i-1][0][2][3] + dp[i-1][1][2][3] + dp[i-1][2][2][3] + dp[i-1][3][2][3]) % MOD; //GTG
        dp[i][2][3][3] = (dp[i-1][0][2][3] + dp[i-1][1][2][3] + dp[i-1][2][2][3] + dp[i-1][3][2][3]) % MOD; //GTT

        //                         A                  C                  G                  T
        dp[i][3][0][0] = (dp[i-1][0][3][0] + dp[i-1][1][3][0] + dp[i-1][2][3][0] + dp[i-1][3][3][0]) % MOD; //TAA
        dp[i][3][0][1] = (dp[i-1][0][3][0] + dp[i-1][1][3][0] + dp[i-1][2][3][0] + dp[i-1][3][3][0]) % MOD; //TAC
        dp[i][3][0][2] = (dp[i-1][0][3][0] + dp[i-1][1][3][0] + dp[i-1][2][3][0] + dp[i-1][3][3][0]) % MOD; //TAG
        dp[i][3][0][3] = (dp[i-1][0][3][0] + dp[i-1][1][3][0] + dp[i-1][2][3][0] + dp[i-1][3][3][0]) % MOD; //TAT

        dp[i][3][1][0] = (dp[i-1][0][3][1] + dp[i-1][1][3][1] + dp[i-1][2][3][1] + dp[i-1][3][3][1]) % MOD; //TCA
        dp[i][3][1][1] = (dp[i-1][0][3][1] + dp[i-1][1][3][1] + dp[i-1][2][3][1] + dp[i-1][3][3][1]) % MOD; //TCC
        dp[i][3][1][2] = (dp[i-1][0][3][1] + dp[i-1][1][3][1] + dp[i-1][2][3][1] + dp[i-1][3][3][1]) % MOD; //TCG
        dp[i][3][1][3] = (dp[i-1][0][3][1] + dp[i-1][1][3][1] + dp[i-1][2][3][1] + dp[i-1][3][3][1]) % MOD; //TCT

        dp[i][3][2][0] = (dp[i-1][0][3][2] + dp[i-1][1][3][2] + dp[i-1][2][3][2] + dp[i-1][3][3][2]) % MOD; //TGA
        dp[i][3][2][1] = (                   dp[i-1][1][3][2] + dp[i-1][2][3][2] + dp[i-1][3][3][2]) % MOD; //TGC
        dp[i][3][2][2] = (dp[i-1][0][3][2] + dp[i-1][1][3][2] + dp[i-1][2][3][2] + dp[i-1][3][3][2]) % MOD; //TGG
        dp[i][3][2][3] = (dp[i-1][0][3][2] + dp[i-1][1][3][2] + dp[i-1][2][3][2] + dp[i-1][3][3][2]) % MOD; //TGT

        dp[i][3][3][0] = (dp[i-1][0][3][3] + dp[i-1][1][3][3] + dp[i-1][2][3][3] + dp[i-1][3][3][3]) % MOD; //TTA
        dp[i][3][3][1] = (dp[i-1][0][3][3] + dp[i-1][1][3][3] + dp[i-1][2][3][3] + dp[i-1][3][3][3]) % MOD; //TTC
        dp[i][3][3][2] = (dp[i-1][0][3][3] + dp[i-1][1][3][3] + dp[i-1][2][3][3] + dp[i-1][3][3][3]) % MOD; //TTG
        dp[i][3][3][3] = (dp[i-1][0][3][3] + dp[i-1][1][3][3] + dp[i-1][2][3][3] + dp[i-1][3][3][3]) % MOD; //TTT
    }

    LL ans = 0;
    REP(i, 4) REP(j, 4) REP(k, 4) ans = (ans + dp[n-1][i][j][k]) % MOD;
    cout << ans << endl;
}

Measured memory_bytes: 384