#include<iostream>

#include<stdio.h>

#include<string.h>

using namespace std;

#define BIT(i, j) (i & (1 << (j - 1)))

const int mod = ;

int dp[][][][];

/*记忆化搜索

n,m为边界n行，m列。

求第i行，第j列位置开始扩展，且第i行的占用状态为s1, 第i+1行的占用状态为s2 时，填满剩余的空格的方案总数

*/

int dfs(int n, int m, int i, int j, int s1, int s2){

    if (dp[i][j][s1][s2] != -)

        return dp[i][j][s1][s2];

    int result = ;

    //边界！！ 无法继续扩展时，取值为1，表示所有扩展到此的合理情况的初始均为1

    if (i > n || j > m || s1 >= ( << m) || s2 >= ( << m))

        return ;

    //如果第i行位置j（从右向左）被占用，且j < m，向左扩展

    if (BIT(s1, j) && j < m)

        result = dfs(n, m, i, j + , s1, s2);

    //如果第i行位置j（从右向左）被占用，且j = m，向下一行扩展

    else if (BIT(s1, j) && j == m)

        result = dfs(n, m, i + , , s2, );

    //如果第i行位置j没有被占用，且无法向左或者向下扩展

    else if (BIT(s1, j) ==  && (j == m || BIT(s1, j + )) && (i == n || BIT(s2, j)))

        result = ;

    //如果第i行位置j没有被占用，且只能向左扩展

    else if (BIT(s1, j) ==  && j < m && BIT(s1, j + ) ==  && (i == n || BIT(s2, j)))

        result = dfs(n, m, i, j, s1 | ( << (j - )) | ( << j), s2);

    //如果第i行位置j没有被占用，且只能向下扩展

    else if (BIT(s1, j) ==  && (j == m || BIT(s1, j + )) && (i < n && BIT(s2, j) == ))

        result = dfs(n, m, i, j, s1 | ( << (j - )), s2 | ( << (j - )));

    //如果第i行位置j没有被占用，且可以向左或向下扩展

    else if (BIT(s1, j) ==  && j < m && BIT(s1, j + ) ==  && i < n && (BIT(s2, j) == ))

        result = dfs(n, m, i, j, s1 | ( << (j - )) | ( << j), s2) +

        dfs(n, m, i, j, s1 | ( << (j - )), s2 | ( << (j - )));

    //记忆化保存

    return dp[i][j][s1][s2] = result % mod;

}

//动归数组， dp2[i][k1][k2] 表示前i-1行都已经填满了，此时第i行的占用情况的二进制表示转换为十进制为 k1，

// 第i+1行的占用情况的二进制表示转换为十进制为 k2

int dp2[][][];

int main(){

    int n, m;

    scanf("%d %d", &n, &m);

    /*

    记忆化搜索

    memset(dp, -1, sizeof(dp));

    int result = dfs(n, m, 1, 1, 0, 0);

    printf("%d\n", result);

    */

    //动态规划

    memset(dp2, , sizeof(dp2));

    //初始状态，第1行未被占用，只有1种可能。

    dp2[][][] = ;

    int mx =  << m;

    for (int i = ; i <= n; i++){
　　　　/*
　　　　　　下面的 j （第i行从右到左的每个位置）循环放在 k1(第i行当前的bit状态) 之前是为了去除重复！ 因为我们总是按照顺序从上到下，从右到左枚举当前可以放置方块的位置点，
　　　　　　在循环到每个（i, j）点，都看当前的哪些k1状态可以在次扩展
　　　　*/

        for (int j = ; j <= m; j++){

            //枚举第i行的所有情况（占用情况的二进制表示转换为十进制）

            for (int k1 = ; k1 < mx; k1++){

                //如果第i行的第j个位置（从右向左）为0，则可以从这里开始扩展

                if ((k1 & ( << (j - ))) == ){

                    //看是否可以横向扩展

                    if (j < m && ( (( << j) & k1) == )){

                        //状态转移

                        for (int k2 = ; k2 < mx; k2++){

                            dp2[i][k1 | ( << j) | ( << (j - ))][k2] =

                                (dp2[i][k1 | ( << j) | ( << (j - ))][k2] + dp2[i][k1][k2]) % mod;

                        }

                    }

                    if (i < n) //看是否可以纵向扩展

                        //当前的第i+1行的占用情况

                        for (int k2 = ; k2 < mx; k2++){

                            //如果第i+1行的第j个位置（从右向左）为0，则可以纵向扩展

                            if ((( << (j-)) & k2) == )

                                //状态转移

                                dp2[i][k1 | ( << (j - ))][k2 | ( << (j - ))] =

                                (dp2[i][k1 | ( << (j - ))][k2 | ( << (j - ))] + dp2[i][k1][k2]) % mod;

                        }

                }

            }

        }

        //当第i行全部被占用满时，可以将第i+1行的状态 转移到 i+1行的当前行

        for (int k = ; k < mx; k++){

            dp2[i + ][k][] = dp2[i][mx - ][k];

        }

    }

    //最后的结果是n行全部占满，此时第n行为 mx-1， 第n+1行为0

    printf("%d\n", dp2[n][mx-][]);

    return ;

}