# Appreciation

/*
 * Problem :: 14852 / 타일 채우기 3
 *
 * Kind :: Dynamic Programming
 *
 * Insight
 * - 타일의 끝마무리 모양을 생각해보자
 *   ㅁ = 1x1, ㅣ = 2x1, ㅡ = 1x2
 *   + 2x1
 *     ㅁ ㅣ
 *     ㅁ ㅣ => 2개
 *   + 2x2
 *     ㅡㅡ ㅡㅡ ㅁㅁ
 *     ㅡㅡ ㅁㅁ ㅡㅡ => 3개
 *   + 2x3
 *     ㅁㅡㅡ ㅡㅡㅁ
 *     ㅡㅡㅁ ㅁㅡㅡ => 2개
 *   + 2x4
 *     ㅁㅡㅡㅁ ㅡㅡㅡㅡ
 *     ㅡㅡㅡㅡ ㅁㅡㅡㅁ => 2개
 *   + 2x5
 *     ㅁㅡㅡㅡㅡ ㅡㅡㅡㅡㅁ
 *     ㅡㅡㅡㅡㅁ ㅁㅡㅡㅡㅡ => 2개
 *     ...
 *     # dp[i] = 2*dp[i-1]
 *               + 3*dp[i-2]
 *               + 2*dp[i-3]
 *               + 2*dp[i-4]
 *               + ...
 *               + 2*dp[1]
 *               + 2*dp[0]
 *       그런데 이렇게 풀면 시간초과가 난다 <= O(N^2)
 *       O(N) 으로 풀 수는 없을까?
 *       -> dp[i] = 2*(dp[i-1] + dp[i-2] + ... + dp[1] + dp[0]) + dp[i-2]
 *          dp[i-1] 부터 dp[0] 까지의 합을 기록하는 DP 를 하나더 만들면 되겠다!
 *          기존 dp 를 dp1, 위의 dp 를 dp2 라고 하면
 *          dp1[i] = 2*dp2[i-1] + dp1[i-2]
 *          dp2[i] = dp2[i-1] + dp1[i]
 *
 * Point
 * - 연산할 때마다 1,000,000,007 로 나누어주는 것을 잊지말자
 */

# Code

//
//  BOJ
//  ver.C++
//
//  Created by GGlifer
//
//  Open Source

#include <iostream>
#include <cstring>

using namespace std;

#define endl '\n'

// Set up : Global Variables
#define MOD 1000000007

// Set up : Functions Declaration
/* None */


int main()
{
    // Set up : I/O
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // Set up : Input
    int N; cin >> N;

    // Process
    int dp1[N+1]; /* dp1[i] = 2xi 크기의 벽을 타일로 채우는 경우의 수 */
    memset(dp1, 0, sizeof(dp1));
    dp1[0] = 1;
    dp1[1] = 2;
    int dp2[N+1]; /* dp2[i] = 2x(0~i) 크기의 벽을 타일로 채우는 경우의 수의 총합 */
    memset(dp2, 0, sizeof(dp2));
    dp2[0] = 1;
    dp2[1] = 3;

    for (int i=2; i<=N; i++) {
        dp1[i] = dp2[i-1]*2;
        dp1[i] %= MOD;
        dp1[i] += dp1[i-2];
        dp1[i] %= MOD;

        dp2[i] = dp2[i-1] + dp1[i];
        dp2[i] %= MOD;
    }

    // Control : Output
    cout << dp1[N] << endl;
}

// Helper Functions
/* None */