#ifdef LOCAL
#include <cstdio>
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstring>
#else
#include <bits/stdc++.h>
#endif
using namespace std ;

typedef long long ll ;
typedef unsigned long long ull ;
#define rep(i , n ) for ( int i =0; i < n ; i++)
#define rrep(i , n) for ( int i = n-1; i >=0 ; i--)

#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;

class UnionFind {
private:
	ull size_; 
	std::vector<ull> par, rank, count;

public:
	UnionFind() : size_(0), par(std::vector<ull>()), rank(std::vector<ull>()), count(std::vector<ull>()) {};
	UnionFind(ull size__) : size_(size__) {
		par.resize(size_); rank.resize(size_); count.resize(size__);
		for (ull i = 0; i < size_; i++) par[i] = i, rank[i] = 0, count[i] = 1;
	}
	ull size() { return size_; }
	// ull root(ull x) { return par[x] == x ? x : par[x] = root(par[x]); }
	
	ull root(ull x)
	{
		while(par[x] != x)
		{
			par[x] = par[par[x]];
			x = par[x];
		}
		return x;
	}
	
	bool same(ull x, ull y) { return root(x) == root(y); }

	void unite(ull x, ull y) {
		x = root(x), y = root(y);
		if (x == y) return;
		if (rank[x] < rank[y]) par[x] = y, count[y]+=count[x], count[x]=0;
		else if (rank[x] == rank[y]) par[y] = x, rank[x]++, count[x]+=count[y], count[y]=0;
		else par[y] = x, count[x] += count[y], count[y] = 0;
	}

	ull size__(ull x)
	{
		return count[root(x)];
	}

	bool operator==(const UnionFind &u) { return par == u.par; }
	bool operator!=(const UnionFind &u) { return par != u.par; }
};
/*
maybe sth wrong 
got wa in one problem
*/
ll modpow(ll a, ll b)
{
	if (b == 0)
	{
		return 1;
	}

	if (b % 2)
	{
		return a * modpow(a, b-1) % MOD;
	}
	else
	{
		ll halfB = b / 2;
		ll half = modpow(a, halfB);
		return half * half % MOD;
	}
}

ll calcComb(ll n, ll m)
{
	if (m > n-m)
	{
		return calcComb(n, n-m);
	}

	ll ansMul = 1;
	ll ansDiv = 1;

	rep(i, m)
	{
		ansMul *= (n-i);
		ansDiv *= (i+1);
		ansMul %= MOD;
		ansDiv %= MOD;
	}

	return ansMul * modpow(ansDiv, MOD - 2) % MOD;
}

__attribute__((constructor))
void initial()
{
	cin.tie(NULL);
	ios::sync_with_stdio(false);
}

#if 0
int ans = 0;

void dfs(string s, int l, int total)
{
	//cout <<"s=" << s << ";l = " << l << endl;

	if (l >= 3)
	{
		string sub = s.substr(l-3);
		//cout << "sub=" << sub << endl;
		if ((sub == "ACG") || (sub == "GAC") || (sub == "AGC"))
		{
			return;
		}
		if (l >= 4)
		{
			//string sub2 = s.substr(l-4);
			string sub_p = s.substr(l-4, 2);
			string sub_s = s.substr(l-2);
			if ((sub_p == "AG") && ((s[l-2] == 'C') || (s[l-1] == 'C')))
			{
				return;
			}

			if ((sub_s == "CG") && ((s[l-4] == 'A') || (s[l-3] == 'A')))
			{
				return;
			}
		}
	}
	if (l >= total)
	{
		ans++;
		return;
	}
	dfs(s+'A', l+1, total);
	dfs(s+'T', l+1, total);
	dfs(s+'G', l+1, total);
	dfs(s+'C', l+1, total);
}

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

	//dfs("", 0, N);
	
	ll tmp = 4;

	rep(i, N - 1)
	{
		tmp = tmp * 4 % MOD;
	}
	//cout << tmp << endl;

	
	//cout << calcComb(N, 4) << endl;
	if (N>=4)
	{
		cout << tmp - calcComb(N, 4) * 26 % MOD << endl;
	}
	else
	{
		cout << tmp - 3 << endl;
	}
	
	//cout << ans << endl;
	
	return 0;
}
#endif

int dp[101][4][4][4];

int main()
{
	int n;
	cin >> n;

	dp[0][3][3][3] = 1;

	rep(len, n)
	{
		rep(i, 4)
		{
			rep(j, 4)
			{
				rep(k, 4)
				{
					if (dp[len][i][j][k] == 0)
					{
						continue;
					}

					rep(a, 4)
					{
						if (a == 2 && (i == 0) && (j == 1)) continue;
						if (a == 2 && (i == 1) && (j == 0)) continue;
						if (a == 1 && (i == 2) && (j == 0)) continue;
						if (a == 2 && (i == 1) && (k == 0)) continue;
						if (a == 2 && (j == 1) && (k == 0)) continue;

						dp[len+1][a][i][j] += dp[len][i][j][k];
						dp[len+1][a][i][j] %= MOD;
					}
				}
			}
		}
	}
	int ans = 0;

	rep(i, 4)
	{
		rep(j, 4)
		{
			rep(k, 4)
			{
				ans += dp[n][i][j][k];
				ans %= MOD;
			}
		}
	}

	cout << ans << endl;

	return 0;
}

Measured memory_bytes: 256