#include <algorithm>
#include <stdio.h>
#include <vector>
typedef long long llt;
typedef unsigned uint;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _max(T&a,T b){return(a<b)?a=b,true:false;}
template<typename T>bol _min(T&a,T b){return(b<a)?a=b,true:false;}
template<typename T>T lowbit(T n){return n&-n;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T lcm(T a,T b){return(a!=0||b!=0)?a/gcd(a,b)*b:(T)0;}
template<typename T>T exgcd(T a,T b,T&x,T&y){if(b!=0){T ans=exgcd(b,a%b,y,x);y-=a/b*x;return ans;}else return y=0,x=1,a;}
template<typename T>T power(T base,T index,T mod)
{
    T ans=1%mod;
    while(index)
    {
        if(index&1)ans=ans*base%mod;
        base=base*base%mod,index>>=1;
    }
    return ans;
}
namespace AnyMod
{
    ullt Mod=-1;
    inline voi ChgMod(ullt v){Mod=v;}
    struct ModInt
    {
        private:
            ullt v;inline ullt chg(ullt w){return(w<Mod)?w:w-Mod;}
            inline ModInt _chg(ullt w){ModInt ans;ans.v=(w<Mod)?w:w-Mod;return ans;}
        public:
            ModInt():v(0){}
            ModInt(ullt v):v(v%Mod){}
            bol empty(){return!v;}
            inline ullt val(){return v;}
            friend bol operator<(ModInt a,ModInt b){return a.v<b.v;}
            friend bol operator>(ModInt a,ModInt b){return a.v>b.v;}
            friend bol operator<=(ModInt a,ModInt b){return a.v<=b.v;}
            friend bol operator>=(ModInt a,ModInt b){return a.v>=b.v;}
            friend bol operator==(ModInt a,ModInt b){return a.v==b.v;}
            friend bol operator!=(ModInt a,ModInt b){return a.v!=b.v;}
            inline friend ModInt operator+(ModInt a,ModInt b){return a._chg(a.v+b.v);}
            inline friend ModInt operator-(ModInt a,ModInt b){return a._chg(a.v+a.chg(Mod-b.v));}
            inline friend ModInt operator*(ModInt a,ModInt b){return a.v*b.v;}
            friend ModInt operator/(ModInt a,ModInt b){return b._power(Mod-2)*a.v;}
            friend ModInt operator^(ModInt a,ullt b){return a._power(b);}
            inline ModInt operator-(){return _chg(Mod-v);}
            ModInt sqrt()
            {
                if(power(v,(Mod-1)>>1,Mod)!=1)return 0;
                ModInt b=1;do b++;while(b._power((Mod-1)>>1)==1);
                ullt t=Mod-1,s=0,k=1;while(!(t&1))s++,t>>=1;
                ModInt x=_power((t+1)>>1),e=_power(t);
                while(k<s)
                {
                    if(e._power(1llu<<(s-k-1))!=1)x*=b._power((1llu<<(k-1))*t);
                    e=_power(Mod-2)*x*x,k++;
                }
                return _min(x,-x),x;
            }
            ModInt inv(){return _power(Mod-2);}
            ModInt _power(ullt index){ModInt ans(1),w(v);while(index){if(index&1)ans*=w;w*=w,index>>=1;}return ans;}
            voi read(){v=0;chr c;do c=getchar();while(c>'9'||c<'0');do v=(c-'0'+v*10)%Mod,c=getchar();while(c>='0'&&c<='9');v%=Mod;}
            voi print()
            {
                static chr C[20];uint tp=0;
                ullt w=v;do C[tp++]=w%10+'0',w/=10;while(w);
                while(tp--)putchar(C[tp]);
            }
            voi println(){print(),putchar('\n');}
            ModInt operator++(int){ModInt ans=*this;return v=chg(v+1),ans;}
        public:
            inline ullt&operator()(){return v;}
            inline ModInt&operator+=(ModInt b){return*this=_chg(v+b.v);}
            inline ModInt&operator-=(ModInt b){return*this=_chg(v+chg(Mod-b.v));}
            inline ModInt&operator*=(ModInt b){return*this=v*b.v;}
            ModInt&operator^=(ullt b){return*this=_power(b);}
            ModInt&operator/=(ModInt b){return*this=b._power(Mod-2)*v;}
            ModInt&operator++(){return v=chg(v+1),*this;}
    };
}
namespace BF_POLY
{
    typedef AnyMod::ModInt modint;
    typedef std::vector<modint>modvec;
    struct poly
    {
        std::vector<modint>V;
        poly(){}
        poly(uint n){V.resize(n);}
        poly(std::vector<modint>V):V(V){}
        inline modint&operator[](uint n){return V[n];};
		inline voi bzr(){V.clear();}
		inline voi push(modint v){V.push_back(v);}
		inline voi pop(){V.pop_back();}
		inline voi cut_zero(){while(!V.empty()&&V.back().empty())V.pop_back();}
		inline voi chg_siz(uint n){V.resize(n);}
		inline voi chg_deg(uint n){V.resize(n+1);}
		inline bol empty(){return cut_zero(),V.empty();}
		inline uint size(){return V.size();}
		inline uint deg(){return V.size()-1;}
		inline modint val(uint n){return(n<size())?V[n]:0;}
        inline modvec GET(){return V;}
        poly reverse()
        {
            poly ans;for(uint i=size()-1;~i;i--)ans.push(V[i]);
            return ans;
        }
		friend poly operator+(poly a,poly b)
		{
			if(a.size()<b.size())a.chg_siz(b.size());
			for(uint i=0;i<b.size();i++)a[i]+=b[i];
			a.cut_zero();return a;
		}
		friend poly operator+(poly a,modint v)
		{
			if(!a.size())a.chg_siz(1);
			a[0]+=v;return a;
		}
		friend poly operator+(modint v,poly a)
		{
			if(!a.size())a.chg_siz(1);
			a[0]+=v;return a;
		}
		friend poly operator-(poly a){
            for(auto&s:a.V)s=-s;
            return a;
        }
		friend poly operator-(poly a,poly b)
		{
			if(a.size()<b.size())a.chg_siz(b.size());
			for(uint i=0;i<b.size();i++)a[i]-=b[i];
			a.cut_zero();return a;
		}
		friend poly operator-(poly a,modint v)
		{
			if(!a.size())a.chg_siz(1);
			a[0]-=v;return a;
		}
		friend poly operator-(modint v,poly a)
		{
			if(!a.size())a.chg_siz(1);
			a[0]-=v;return-a;
		}
		friend poly operator*(poly a,poly b)
		{
            poly ans;ans.chg_siz(a.size()+b.size());
            for(uint i=0;i<a.size();i++)for(uint j=0;j<b.size();j++)ans[i+j]+=a[i]*b[j];
            ans.cut_zero();
            return ans;
		}
        friend poly operator*(poly A,modint b)
        {
            for(auto&s:A.V)s*=b;
            return A;
        }
        friend poly operator*(modint b,poly A)
        {
            for(auto&s:A.V)s*=b;
            return A;
        }
        friend poly operator<<(poly a,uint k)
        {
        	poly ans;ans.chg_siz(k);for(auto v:a.V)ans.push(v);
        	return ans;
        }
        friend poly operator>>(poly a,uint k)
        {
        	poly ans;for(uint i=k;i<a.size();i++)ans.push(a[i]);
        	return ans;
        }
        friend poly sub_mul(poly a,poly b)
        {
            uint len=(a=a.reverse()).size();
            a=a*b;a.chg_siz(len);a=a.reverse();
            return a;
        }
        poly inv(){return inv(size());}
        poly inv(uint prec)
        {
            if(!prec||!val(0)())return poly();
            poly ans(prec);ans[0]=V[0].inv();
            for(uint i=1;i<prec;i++)
            {
                for(uint j=1;j<=i;j++)ans[i]+=ans[i-j]*val(j);
                ans[i]*=-ans[0];
            }
            return ans;
        }
        poly exp(){return exp(size());}
        poly exp(uint prec)
        {
            if(!prec||val(0)())return poly();
            poly ans(prec);
            ans[0]=1;
            for(uint i=1;i<prec;i++)
            {
                for(uint j=0;j<i;j++)ans[i]+=val(i-j)*(i-j)*ans[j];
                ans[i]/=i;
            }
            return ans;
        }
        poly sqrt(){return sqrt(size());}
        poly sqrt(uint prec)
        {
            if(!prec||!val(0)())return poly();
            poly ans(prec);
            ans[0]=V[0]==1?1:V[0].sqrt();
            modint v=ans[0].inv()/2;
            for(uint i=1;i<prec;i++)
            {
                ans[i]=val(i);
                for(uint j=1;j<i;j++)ans[i]-=ans[j]*ans[i-j];
                ans[i]*=v;
            }
            return ans;
        }
        poly&operator+=(poly b)
        {
			if(size()<b.size())chg_siz(b.size());
			for(uint i=0;i<b.size();i++)V[i]+=b[i];
			cut_zero();return*this;
        }
        inline poly&operator+=(modint v)
        {
        	if(!size())chg_siz(1);
        	V[0]+=v;return*this;
        }
        poly&operator-=(poly b)
        {
			if(size()<b.size())chg_siz(b.size());
			for(uint i=0;i<b.size();i++)V[i]-=b[i];
			cut_zero();return*this;
        }
        inline poly&operator-=(modint v)
        {
        	if(!size())chg_siz(1);
        	V[0]-=v;return*this;
        }
        poly&operator*=(poly b){return*this=*this*b;}
        poly&operator*=(modint v)
        {
        	for(auto&t:V)t*=v;
			return*this;
        }
        poly&operator<<=(uint v){return*this=*this<<v;}
        poly&operator>>=(uint v){return*this=*this>>v;}
    };
    struct cpd
    {
        modint point_eval(poly P,modint x)
        {
            modint ans;
            for(uint i=P.deg();~i;i--)ans=ans*x+P[i];
            return ans;
        }
        poly z_npow(poly P,uint n)
        {
            if(P.empty())return P;
            poly ans(P.deg()*n+1);
            for(uint i=0;i<P.size();i++)ans[i*n]+=P[i];
            return ans;
        }
        poly z_npow(poly P,uint n,uint prec)
        {
            poly ans(prec);
            for(uint i=0;i<P.size()&&i*n<prec;i++)ans[i*n]+=P[i];
            return ans;
        }
        poly z_mul_k(poly P,modint k)
        {
            modint t(1);
            for(uint i=0;i<P.size();i++)P[i]*=t,t*=k;
            return P;
        }
        poly z_add_v(poly P,modint v)
        {
            uint n=P.size();if(!n)return P;
            modvec A(n),B(n);
            A[0]=1;for(uint i=1;i<n;i++)A[i]=A[i-1]*i;
            B[n-1]=A[n-1].inv();for(uint i=n-1;i;i--)B[i-1]=B[i]*i;
            poly User(n);modint w(1);
            for(uint i=0;i<n;i++)P[i]*=A[i],User[i]=w*B[i],w*=v;
            P=sub_mul(P,User),P.chg_siz(n);
            for(uint i=0;i<n;i++)P[i]*=B[i];
            return P;
        }
        poly chg_siz(poly P,uint siz){P.chg_siz(siz);return P;}
        poly PolyaInv(poly P,uint prec){return(modint(1)-P).inv(prec);}
        poly PolyaInv(poly P){return PolyaInv(P,P.size());}
        voi println(poly P,uint n)
        {
            for(uint i=0;i<n;i++){
                if(i)putchar(' ');
                P.val(i).print();
            }
            putchar('\n');
        }
        voi println(poly P){println(P,P.size());}
        poly LIM_MUL(poly a,poly b,uint lim)
        {
            poly ans;ans.chg_siz(lim);
            for(uint i=0;i<a.size();i++)for(uint j=0;j<b.size()&&i+j<lim;j++)ans[i+j]+=a[i]*b[j];
            ans.cut_zero();
            return ans;
        }
        poly Max_Mul(poly a,poly b)
        {
            poly ans(std::max(a.size(),b.size()));
            modint v=0;for(uint i=0;i<a.size();i++)v+=b.val(i),ans[i]+=v*a[i];
            v=0;for(uint i=0;i<b.size();i++)ans[i]+=v*b[i],v+=a.val(i);
            return ans;
        }
    };
};
using namespace BF_POLY;
modint P[4005],Q[4005];
poly Pow(poly P,uint index)
{
    poly ans(modvec{1});
    while(index)
    {
        if(index&1)ans*=P;
        P*=P,index>>=1;
    }
    return ans;
}
poly Get(uint n)
{
    poly ans(n/2+1);ans[0]=1;
    for(uint i=0;i<n/2;i++)ans[i+1]=ans[i]*(n-2*i)*(n-2*i-1);
    for(uint i=0;i<=n/2;i++)ans[i]*=Q[i];
    return ans;
}
int main()
{
    AnyMod::ChgMod(1e9+7);
    uint n,m;scanf("%u%u",&n,&m);
    uint LIM=n<<1;
    P[0]=1;for(uint i=1;i<=LIM;i++)P[i]=P[i-1]*i;
    Q[LIM]=P[LIM].inv();for(uint i=LIM;i;i--)Q[i-1]=Q[i]*i;
    uint w=n*2/m;uint cnt1=n*2%m;uint cnt0=m-cnt1;
    poly X=Pow(Get(w),cnt0)*Pow(Get(w+1),cnt1);
    modint ans=0;
    for(uint i=0;i<=n;i++)ans+=X.val(i)*((i&1)?-modint(1):1)*P[n]*Q[n-i]*P[n*2-i*2];
    ans.println();
    return 0;
}