#define ENABLE_DEBUG 1
// Kana's kitchen {{{
#include<bits/stdc++.h>
#define ALL(v) std::begin(v), std::end(v)
#define REP(i, k) for (decltype(k) i = 0; i < k; i++)
#define LOOP(k) REP (ngtkana_is_a_genius, k)

using i32 = std::int_least32_t;
using i64 = std::int_least64_t;
using u32 = std::uint_least32_t;
using u64 = std::uint_least64_t;
using usize = std::size_t;

template <class T, class U> using pair = std::pair<U, T>;
template <class T> using diag_pair = std::pair<T, T>;
template <class... Args> using tuple = std::tuple<Args...>;
template <class T> using vec = std::vector<T>;
template <class T> using numr = std::numeric_limits<T>;

#ifdef NGTKANA
#include<debug.hpp>
#else
#define DEBUG(...)(void)0
#endif
/*}}}*/
// mint{{{
template <class ModType> struct modint {
    using value_type = typename ModType::value_type;
    using mint = modint<ModType>;
    using mod_type = ModType;

    static value_type mod() { return ModType::value; }

    private:
    static value_type inverse(value_type x) {
        value_type y=1,u=mod(),v=0;
        while(x){
            value_type q=u/x;
            u-=q*x; std::swap(x,u);
            v-=q*y; std::swap(y,v);
        }
        assert(x==0 && std::abs(y)==mod() && std::abs(u)==1 && std::abs(v)<mod());
        return v<0?v+mod():v;
    }

    public:
    // the member variable
    value_type value;

    // constructors
    modint()=default;
    modint(modint const&)=default;
    modint(modint&&)=default;
    modint& operator=(modint const&)=default;
    modint& operator=(modint&&)=default;
    ~modint()=default;

    template <class T> modint(T t) : value([t] () mutable {
            if ( t <= -static_cast<T>(mod()) || static_cast<T>(mod()) <= t ) t %= mod();
            return t < 0 ? t + mod() : t;
            }()) {}

    // operators
    mint& operator+= (mint y) {
        value += y.value;
        if (mod() <= value) value -= mod();
        return *this;
    }

    mint& operator-= (mint y) {
        value -= y.value;
        if ( value < 0 ) value += mod();
        return *this;
    }

    mint& operator*= (mint y) {
        value = (long long)value * y.value % mod();
        return *this;
    }

    mint& operator/= (mint y) {
        value = (long long)value * inverse(y.value) % mod();
        return *this;
    }

    mint& operator++() { return *this+=1; }
    mint& operator--() { return *this-=1; }
    mint operator++(int) { mint this_=*this; ++*this; return this_; }
    mint operator--(int) { mint this_=*this; --*this; return this_; }
    mint operator-() const { return 0 - *this; }

    // static member functions
    static mint inv(mint x) { return inverse(x.value); }

    static mint m1pow(long long y) { return y%2?-1:1; }

    static mint pow(mint x, unsigned long long y) {
        mint ans=1;
        for(;y;y>>=1){
            if(y&1ull) ans*=x;
            x*=x;
        }
        return ans;
    }

    // non-member functions
    mint& add_assign(mint y) { return *this+=y; }
    mint& sub_assign(mint y) { return *this-=y; }
    mint& mul_assign(mint y) { return *this*=y; }
    mint& div_assign(mint y) { return *this/=y; }
    mint& inv_assign()       { return *this = inv(*this); }
    mint& pow_assign(unsigned long long y){ return *this = pow(*this, y); }

    mint add(mint y) const { mint ans=*this; return ans.add_assign(y); }
    mint sub(mint y) const { mint ans=*this; return ans.sub_assign(y); }
    mint mul(mint y) const { mint ans=*this; return ans.mul_assign(y); }
    mint div(mint y) const { mint ans=*this; return ans.div_assign(y); }
    mint inv()       const { mint ans=*this; return ans.inv_assign(); }
    mint pow(unsigned long long y) const { return pow(*this, y); }
    mint square(mint x) const { return *this * *this; }
    mint cube(mint x) const { return *this * *this * *this; }

    template <class F> mint map(F const& f){
        value=f(value);
        return *this;
    }
};

template <class T> std::istream&
operator>>(std::istream& is, modint<T>& x) {
    typename modint<T>::value_type y;
    is >> y;
    x = modint<T>{ y };
    return is;
}
template <class T> std::ostream&
operator<<(std::ostream& os, modint<T> x) {
    return os << x.value;
}

template <class T> modint<T> operator+(modint<T> x, modint<T> y) { return x+=y; }
template <class T> modint<T> operator-(modint<T> x, modint<T> y) { return x-=y; }
template <class T> modint<T> operator*(modint<T> x, modint<T> y) { return x*=y; }
template <class T> modint<T> operator/(modint<T> x, modint<T> y) { return x/=y; }
template <class T> bool operator==(modint<T> x, modint<T> y) { return x.value==y.value; }
template <class T> bool operator!=(modint<T> x, modint<T> y) { return x.value!=y.value; }

template <class T, class U> modint<T> operator+(modint<T> x, U y) { return x+modint<T>(y); }
template <class T, class U> modint<T> operator-(modint<T> x, U y) { return x-modint<T>(y); }
template <class T, class U> modint<T> operator*(modint<T> x, U y) { return x*modint<T>(y); }
template <class T, class U> modint<T> operator/(modint<T> x, U y) { return x/modint<T>(y); }
template <class T, class U> bool operator==(modint<T> x, U y) { return x==modint<T>(y); }
template <class T, class U> bool operator!=(modint<T> x, U y) { return x!=modint<T>(y); }

template <class T, class U> modint<T> operator+(U x, modint<T> y) { return modint<T>(x)+y; }
template <class T, class U> modint<T> operator-(U x, modint<T> y) { return modint<T>(x)-y; }
template <class T, class U> modint<T> operator*(U x, modint<T> y) { return modint<T>(x)*y; }
template <class T, class U> modint<T> operator/(U x, modint<T> y) { return modint<T>(x)/y; }
template <class T, class U> bool operator==(U x, modint<T> y) { return modint<T>(x)==y; }
template <class T, class U> bool operator!=(U x, modint<T> y) { return modint<T>(x)!=y; }
/*}}}*/
using mint = modint<std::integral_constant<i64, 1'000'000'007>>;
template <usize N, class T, class... Args, std::enable_if_t<N==0, int> = 0>
auto mkvec(Args... args) {
    return T(args...);
}
template <usize N, class T, class... Args, std::enable_if_t<N!=0, int> = 0>
auto mkvec(usize sz, Args... args) {
    using value_type = std::decay_t<decltype(mkvec<N-1, T>(args...))>;
    return vec<value_type>(sz, mkvec<N-1, T>(args...));
}
int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    std::cout << std::setprecision(15) << std::fixed;

    u32 n, m; std::cin >> n >> m;
    auto dp = mkvec<2, mint>(2, n);
    dp.at(1).at(0) = 1;
    for (usize i=1; i<n; i++) dp.at(0).at(i) = 1;
    m--;
    while (m--) {
        auto swp = mkvec<2, mint>(2, n);
        // j が 1 増えるもの
        for (usize j=1; j<n-1; j++) swp.at(0).at(j+1) += dp.at(0).at(j);
        for (usize j=0; j<n-1; j++) swp.at(1).at(j+1) += dp.at(1).at(j);
        // j が変わらないもの
        REP (i, 2) REP (j, n) swp.at(i).at(j) += 2 * dp.at(i).at(j);
        // j が 1 減るもの
        for (usize j=2; j<n; j++) swp.at(0).at(j-1) += dp.at(0).at(j);
        if (1!=n) swp.at(1).at(0) += dp.at(0).at(1);
        for (usize j=1; j<n; j++) swp.at(1).at(j-1) += dp.at(1).at(j);
        swp.swap(dp);
    }

    std::cout << std::accumulate(ALL(dp.at(1)), mint{0}) * 4 << '\n';
}

/*
 * クエリにお名前をつけます。
 * P: 好きな積み木を箱から 1 つ取り出す。
 * Q: 赤い積み木と青い積み木を 1 つずつ箱にいれる。
 *
 * 色にお名前をつけます。
 * A: 赤
 * B: 青
 *
 * PQP を繰り返すとのことですが、はじめに P をして、QPP を M - 1 回繰り返して、最後に QP をするとしてよいです。
 * はじめの P は特別扱いです。好きな積み木を取り出したことにして、好きな N - 1 個を袋に入れればよいです。
 *
 * QPP の形にしておくと、
 * - AB、BA は必ずできて、状態が変化しません。
 * - A があれば AA ができて、A が一つ減ります。
 * - B があれば BB ができて、B が一つ減ります。
 *
 * さて、まずははじめにいくつの玉を入れたのかを区別して数えることを考えましょう。
 * ある場所まで操作したとして、残りの (A, B) の個数が、(j, N - 1 - j) であるような場合の数を、dp[j] と置きましょう。
 * dp[j+1] ←  dp'[j] if j ≠ N - 1
 * dp[j]   ←  dp'[j]
 * dp[j-1] ←  dp'[j] if j ≠ 0
 * のように遷移します。
 *
 * 初期状態は、all 2 です。
 * 遷移が終わったあとは、最後の一つは何でも取れますから、sum の 2 倍です。
 * つまり、all 1 から遷移して最後に 4 倍でも大丈夫です。
 *
 * では、区別しない場合を考えます。これは、どこかのタイミングで j = 0 になる経路を数えればよいです。
 * j = 0 を経由したかとき、i を true にしましょう。
 *
 * j が 1 増えるもの
 * dp[0][j+1] ← dp'[0][j] if j ≠ 0, N - 1
 * dp[1][j+1] ← dp'[1][j] if j ≠ N - 1
 *
 * j が変わらないもの
 * dp[i][j]   ← dp'[i][j]
 *
 * j が 1 減るもの
 * dp[0][j-1] ← dp'[0][j] if j ≠ 0, 1
 * dp[1][0]   ← dp'[0][1]
 * dp[1][j-1] ← dp'[1][j] if j ≠ 0
 */


Measured memory_bytes: 384