#include <bits/stdc++.h>
using namespace std;
#define int long long
#define p (int)(1e9 + 7)

int MOD(int a){
	if(a < p) return a;
	else if(a < p + p) return a - p;
	else return a % p;
}

int power(int a, int N){
	if(N == 0){
		return 1;
	}
	else if(N % 2 == 0){
		return power(MOD(a * a), N / 2);
	}
	else{
		return MOD(a * power(a, N - 1));
	}
}

signed main(){
	int N, M, i, j, b;
	scanf("%lld%lld", &N, &M);
	if(N == 1){
		printf("%lld\n", power(2, M + 1));
		return 0;
	}
	int ans = 0;
	if(N >= 3){
		vector<vector<vector<int>>> dp1(2, vector<vector<int>>(N - 1, vector<int>(2, 0)));
		for(j = 0; j <= N - 2; j++){
			dp1[0][j][0] = 1;
		}
		dp1[0][0][1] = 1;
		for(i = 1; i <= M; i++){
			b = i % 2;
			dp1[b][0][0] = MOD(2 * dp1[b ^ 1][0][0] + dp1[b ^ 1][1][0]);
			dp1[b][0][1] = dp1[b][0][0];
			for(j = 1; j < N - 2; j++){
				dp1[b][j][0] = MOD(dp1[b ^ 1][j - 1][0] + 2 * dp1[b ^ 1][j][0] + dp1[b ^ 1][j + 1][0]);
				dp1[b][j][1] = MOD(dp1[b ^ 1][j - 1][1] + 2 * dp1[b ^ 1][j][1] + dp1[b ^ 1][j + 1][1]);
			}
			dp1[b][N - 2][0] = MOD(dp1[b ^ 1][N - 3][0] + 2 * dp1[b ^ 1][N - 2][0]);
			dp1[b][N - 2][1] = MOD(dp1[b ^ 1][N - 3][1] + 2 * dp1[b ^ 1][N - 2][1]);
		}
		for(j = 0; j <= N - 2; j++){
			ans = MOD(ans + dp1[M % 2][j][1]);
		}
	}
	else if(N == 2){
		ans = MOD(ans + power(2, M));
	}

	vector<vector<vector<int>>> dp2(2, vector<vector<int>>(N, vector<int>(4, 0)));
	for(j = 0; j <= N - 1; j++){
		dp2[0][j][0] = 1;
	}
	dp2[0][0][1] = 1;
	dp2[0][N - 1][2] = 1;
	for(i = 1; i <= M; i++){
		b = i % 2;
		dp2[b][0][0] = MOD(dp2[b ^ 1][0][0] + dp2[b ^ 1][1][0]);
		dp2[b][0][1] = dp2[b][0][0];
		dp2[b][0][2] = MOD(dp2[b ^ 1][0][2] + dp2[b ^ 1][1][2]);
		dp2[b][0][3] = dp2[b][0][2];
		for(j = 1; j < N - 1; j++){
			dp2[b][j][0] = MOD(dp2[b ^ 1][j - 1][0] + 2 * dp2[b ^ 1][j][0] + dp2[b ^ 1][j + 1][0]);
			dp2[b][j][1] = MOD(dp2[b ^ 1][j - 1][1] + 2 * dp2[b ^ 1][j][1] + dp2[b ^ 1][j + 1][1]);
			dp2[b][j][2] = MOD(dp2[b ^ 1][j - 1][2] + 2 * dp2[b ^ 1][j][2] + dp2[b ^ 1][j + 1][2]);
			dp2[b][j][3] = MOD(dp2[b ^ 1][j - 1][3] + 2 * dp2[b ^ 1][j][3] + dp2[b ^ 1][j + 1][3]);
		}
		dp2[b][N - 1][0] = MOD(dp2[b ^ 1][N - 2][0] + 2 * dp2[b ^ 1][N - 1][0]);
		dp2[b][N - 1][1] = MOD(dp2[b ^ 1][N - 2][1] + 2 * dp2[b ^ 1][N - 1][1]);
		dp2[b][N - 1][2] = dp2[b][N - 1][0];
		dp2[b][N - 1][3] = dp2[b][N - 1][1];
	}

	vector<vector<vector<int>>> dp2_2(2, vector<vector<int>>(N, vector<int>(4, 0)));
	for(j = 0; j <= N - 1; j++){
		dp2_2[0][j][0] = 1;
	}
	dp2_2[0][0][1] = 1;
	dp2_2[0][N - 1][2] = 1;
	for(i = 1; i <= M; i++){
		b = i % 2;
		dp2_2[b][0][0] = MOD(dp2_2[b ^ 1][0][0] + dp2_2[b ^ 1][1][0]);
		dp2_2[b][0][1] = dp2_2[b][0][0];
		dp2_2[b][0][2] = MOD(dp2_2[b ^ 1][0][2] + dp2_2[b ^ 1][1][2]);
		dp2_2[b][0][3] = dp2_2[b][0][2];
		for(j = 1; j < N - 1; j++){
			dp2_2[b][j][0] = MOD(dp2_2[b ^ 1][j - 1][0] + 2 * dp2_2[b ^ 1][j][0] + dp2_2[b ^ 1][j + 1][0]);
			dp2_2[b][j][1] = MOD(dp2_2[b ^ 1][j - 1][1] + 2 * dp2_2[b ^ 1][j][1] + dp2_2[b ^ 1][j + 1][1]);
			dp2_2[b][j][2] = MOD(dp2_2[b ^ 1][j - 1][2] + 2 * dp2_2[b ^ 1][j][2] + dp2_2[b ^ 1][j + 1][2]);
			dp2_2[b][j][3] = MOD(dp2_2[b ^ 1][j - 1][3] + 2 * dp2_2[b ^ 1][j][3] + dp2_2[b ^ 1][j + 1][3]);
		}
		dp2_2[b][N - 1][0] = MOD(dp2_2[b ^ 1][N - 2][0] + dp2_2[b ^ 1][N - 1][0]);
		dp2_2[b][N - 1][1] = MOD(dp2_2[b ^ 1][N - 2][1] + dp2_2[b ^ 1][N - 1][1]);
		dp2_2[b][N - 1][2] = dp2_2[b][N - 1][0];
		dp2_2[b][N - 1][3] = dp2_2[b][N - 1][1];
	}

	vector<vector<vector<int>>> dp3(2, vector<vector<int>>(N + 1, vector<int>(4, 0)));
	for(j = 0; j <= N; j++){
		dp3[0][j][0] = 1;
	}
	dp3[0][0][1] = 1;
	dp3[0][N][2] = 1;
	for(i = 1; i <= M; i++){
		b = i % 2;
		dp3[b][0][0] = MOD(dp3[b ^ 1][0][0] + dp3[b ^ 1][1][0]);
		dp3[b][0][1] = dp3[b][0][0];
		dp3[b][0][2] = MOD(dp3[b ^ 1][0][2] + dp3[b ^ 1][1][2]);
		dp3[b][0][3] = dp3[b][0][2];
		for(j = 1; j < N; j++){
			dp3[b][j][0] = MOD(dp3[b ^ 1][j - 1][0] + 2 * dp3[b ^ 1][j][0] + dp3[b ^ 1][j + 1][0]);
			dp3[b][j][1] = MOD(dp3[b ^ 1][j - 1][1] + 2 * dp3[b ^ 1][j][1] + dp3[b ^ 1][j + 1][1]);
			dp3[b][j][2] = MOD(dp3[b ^ 1][j - 1][2] + 2 * dp3[b ^ 1][j][2] + dp3[b ^ 1][j + 1][2]);
			dp3[b][j][3] = MOD(dp3[b ^ 1][j - 1][3] + 2 * dp3[b ^ 1][j][3] + dp3[b ^ 1][j + 1][3]);
		}
		dp3[b][N][0] = MOD(dp3[b ^ 1][N - 1][0] + dp3[b ^ 1][N][0]);
		dp3[b][N][1] = MOD(dp3[b ^ 1][N - 1][1] + dp3[b ^ 1][N][1]);
		dp3[b][N][2] = dp3[b][N][0];
		dp3[b][N][3] = dp3[b][N][1];
	}

	for(j = 0; j <= N - 1; j++){
		ans = MOD(ans + 2 * dp2[M % 2][j][3] - dp2_2[M % 2][j][3] + p);
	}
	for(j = 0; j <= N; j++){
		ans = MOD(ans + dp3[M % 2][j][3]);
	}
	printf("%lld\n", ans);
	return 0;
}

Measured memory_bytes: 1720