#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}


template<typename T,T MOD = 1000000007>
struct Mint{
  static constexpr T mod = MOD;
  T v;
  Mint():v(0){}
  Mint(signed v):v(v){}
  Mint(long long t){v=t%MOD;if(v<0) v+=MOD;}

  Mint pow(long long k){
    Mint res(1),tmp(v);
    while(k){
      if(k&1) res*=tmp;
      tmp*=tmp;
      k>>=1;
    }
    return res;
  }

  static Mint add_identity(){return Mint(0);}
  static Mint mul_identity(){return Mint(1);}

  Mint inv(){return pow(MOD-2);}

  Mint& operator+=(Mint a){v+=a.v;if(v>=MOD)v-=MOD;return *this;}
  Mint& operator-=(Mint a){v+=MOD-a.v;if(v>=MOD)v-=MOD;return *this;}
  Mint& operator*=(Mint a){v=1LL*v*a.v%MOD;return *this;}
  Mint& operator/=(Mint a){return (*this)*=a.inv();}

  Mint operator+(Mint a) const{return Mint(v)+=a;};
  Mint operator-(Mint a) const{return Mint(v)-=a;};
  Mint operator*(Mint a) const{return Mint(v)*=a;};
  Mint operator/(Mint a) const{return Mint(v)/=a;};

  Mint operator-() const{return v?Mint(MOD-v):Mint(v);}

  bool operator==(const Mint a)const{return v==a.v;}
  bool operator!=(const Mint a)const{return v!=a.v;}
  bool operator <(const Mint a)const{return v <a.v;}

  // find x s.t. a^x = b
  static T log(T a,T b){
    const T sq=40000;
    unordered_map<T, T> dp;
    dp.reserve(sq);
    Mint res(1);
    for(Int r=0;r<sq;r++){
      if(!dp.count(res.v)) dp[res.v]=r;
      res*=a;
    }
    Mint p=Mint(a).inv().pow(sq);
    res=b;
    for(Int q=0;q<=MOD/sq+1;q++){
      if(dp.count(res.v)){
        T idx=q*sq+dp[res.v];
        if(idx>0) return idx;
      }
      res*=p;
    }
    assert(0);
    return T(-1);
  }

  static Mint comb(long long n,Int k){
    Mint num(1),dom(1);
    for(Int i=0;i<k;i++){
      num*=Mint(n-i);
      dom*=Mint(i+1);
    }
    return num/dom;
  }
};
template<typename T,T MOD> constexpr T Mint<T, MOD>::mod;
template<typename T,T MOD>
ostream& operator<<(ostream &os,Mint<T, MOD> m){os<<m.v;return os;}


template<typename F>
void all_permutations(Int n,F f){
  vector<Int> vs(n);
  iota(vs.begin(),vs.end(),0);
  do f(vs); while(next_permutation(vs.begin(),vs.end()));
}

using M = Mint<Int>;
const Int MAX = 55;
const Int LEN = 3030;
M dp[MAX][MAX][LEN]={};

//INSERT ABOVE HERE
signed main(){
  Int n,num;
  cin>>n>>num;
  if(num&1){
    cout<<0<<endl;
    return 0;
  }
  num/=2;

  dp[0][0][0]=M(1);
  for(Int i=0;i<n;i++){
    for(Int j=0;j<=i;j++){
      for(Int k=0;k<LEN;k++){

        // i back, 1 umeru
        if(j>0&&k+j<LEN)
          dp[i+1][j-1][k+j]+=dp[i][j][k]*M(j)*M(j);

        // i back, sonomama
        if(k+j-1<LEN)
          dp[i+1][j][k+j]+=dp[i][j][k]*M(j);

        // i oku
        if(k+j<LEN)
          dp[i+1][j][k+j]+=dp[i][j][k];

        // i okanai, 1 umeru
        if(k+j<LEN)
          dp[i+1][j][k+j]+=dp[i][j][k]*M(j);

        // i okanai, sonomama
        if(k+j<LEN)
          dp[i+1][j+1][k+j]+=dp[i][j][k];
      }
    }
  }
  //for(Int k=0;k<=n*n;k++) cout<<dp[n][0][k]<<endl;

  cout<<dp[n][0][num]<<endl;
  return 0;
}


Measured memory_bytes: 71808