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

#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x,y) CPP_CAT_I(x,y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x,y) x ## y

using i8  = int8_t;
using u8  = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;

using f32 = float;
using f64 = double;

#define FOR(i, start, end) for(i64 i = (start), CPP_CAT(i,xxxx_end)=(end); i < CPP_CAT(i,xxxx_end); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) for(i64 i = 1; i <= n; ++i)
#define RREP(i, n) for(i64 i = n - 1; i >= 0 ; --i)
#define RREPS(i, n) for(i64 i = n; i >= 1; --i)

#define ALL(f,c,...) (([&](decltype((c)) cccc) { return (f)(std::begin(cccc), std::end(cccc), ## __VA_ARGS__); })(c))

#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

#define pb push_back
#define mp make_pair
#define F first
#define S second

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

template<typename C>
i64 SIZE(const C& c) { return static_cast<i64>(c.size()); }

template<typename T, size_t N>
i64 SIZE(const T (&)[N]) { return static_cast<i64>(N); }


struct ProconInit {
    static constexpr int IOS_PREC = 15;
    static constexpr bool AUTOFLUSH = false;

    ProconInit() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(IOS_PREC);
        if(AUTOFLUSH)
            cout << unitbuf;
    }
} PROCON_INIT;


template<int MOD>
struct Fp {
    i64 val;
    constexpr Fp(i64 v = 0) noexcept : val(v % MOD) {
        if (val < 0) val += MOD;
    }
    constexpr int getmod() { return MOD; }
    constexpr Fp operator - () const noexcept {
        return val ? MOD - val : 0;
    }
    constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
    constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
    constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
    constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
    constexpr Fp& operator += (const Fp& r) noexcept {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return *this;
    }
    constexpr Fp& operator -= (const Fp& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr Fp& operator *= (const Fp& r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Fp& operator /= (const Fp& r) noexcept {
        i64 a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            i64 t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr bool operator == (const Fp& r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator != (const Fp& r) const noexcept {
        return this->val != r.val;
    }
    constexpr bool operator > (const Fp& r) const noexcept {
        return this->val > r.val;
    }
    constexpr bool operator >= (const Fp& r) const noexcept {
        return this->val >= r.val;
    }
    friend constexpr ostream& operator << (ostream &os, const Fp<MOD>& x) noexcept {
        return os << x.val;
    }
    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, i64 n) noexcept {
        if (n == 0) return 1;
        auto t = modpow(a, n / 2);
        t = t * t;
        if (n & 1) t = t * a;
        return t;
    }
};

#define MAX_N 100
#define MOD 1'000'000'007
using mint = Fp<MOD>;

#define N_CHAR 4
// AGC, GAC, ACG, A?GC, AG?C
mint dp[MAX_N + 1][2][N_CHAR][N_CHAR][N_CHAR];
// A, C, G, T
const char C[4] = {'A', 'C', 'G', 'T'};

int main() {
    i64 N; cin >> N;

    REP(l, N + 1) REP(done, 2) REP(i, N_CHAR) REP(j, N_CHAR) REP(k, N_CHAR) dp[l][done][i][j][k] = 0;
    dp[0][0][3][3][3] = 1;
    REP(l, N) {
        REP(done, 2) {
            REP(im1, N_CHAR) {
                REP(im2, N_CHAR) {
                    REP(im3, N_CHAR) {
                        REP(i, 4) {
                            if (done) {
                                dp[l + 1][done][i][im1][im2] += dp[l][done][im1][im2][im3];
                                continue;
                            }
                            string s = {C[i], C[im1], C[im2], C[im3]};
                            if (s.substr(0, 3) == "AGC") {
                                dp[l + 1][1][0][2][1] += dp[l][done][im1][im2][im3];
                            } else if (s.substr(0, 3) == "GAC") {
                                dp[l + 1][1][2][0][1] += dp[l][done][im1][im2][im3];
                            } else if (s.substr(0, 3) == "ACG") {
                                dp[l + 1][1][0][1][2] += dp[l][done][im1][im2][im3];
                            } else if (s[0] == 'A' && s.substr(2,2) == "GC") {
                                dp[l + 1][1][0][im1][2] += dp[l][done][im1][im2][im3];
                            } else if (s.substr(0, 2) == "AG" && s[3] == 'C') {
                                dp[l + 1][1][0][2][im2] += dp[l][done][im1][im2][im3];
                            } else {
                                dp[l + 1][0][i][im1][im2] += dp[l][done][im1][im2][im3];
                            }
                        }
                    }
                }
            }
        }
    }

    mint cnt = modpow((mint)4, N);
    REP(im1, N_CHAR) {
        REP(im2, N_CHAR) {
            REP(im3, N_CHAR) {
                cnt -= dp[N][1][im1][im2][im3];
            }
        }
    }
    cout << cnt << endl;

    return 0;
}

Measured memory_bytes: 384