#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <algorithm>
#include <complex>
#include <array>
#include <functional>
using namespace std;
 
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define ALL(c) (c).begin(), (c).end()
 
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<double> VD;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<VD> VVD;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;

template<typename T> void chmin(T &a, T b) { if (a > b) a = b; }
template<typename T> void chmax(T &a, T b) { if (a < b) a = b; }

int in() { int x; scanf("%d", &x); return x; }
ll lin() { ll x; scanf("%lld", &x); return x; }

// set<VI> naive(ll n){
//     ll m = 3 * n;
//     VI p(m);
//     REP(i,m) p[i] = i;
//     set<VI> st;
//     do{
//         VVI a(n, VI(3));
//         REP(i,m){
//             a[i / 3][i % 3] = p[i];
//         }
//         VI v, idx(3);
//         REP(i,m){
//             int mi = 1e9, x = -1;
//             REP(j,n){
//                 if (idx[j] == 3) continue;
//                 if (a[j][idx[j]] < mi){
//                     mi = a[j][idx[j]];
//                     x = j;
//                 }
//             }
//             v.push_back(mi);
//             idx[x]++;
//         }
//         st.insert(v);
//     }while (next_permutation(ALL(p)));
//     return st;
// }

// int calc(ll n){
//     ll m = 3 * n;
//     set<VI> st = naive(n);
//     VI p(m);
//     REP(i,m) p[i] = i;
//     int ret = 0;
//     do{
//         int i = m;
//         VI appear(m);
//         bool ok = true;
//         while (i > 0){
//             // cout << i << endl;
//             int ne = m;
//             FORR(j,m-1,0){
//                 if (!appear[j]){
//                     ne = j;
//                     break;
//                 }
//             }
//             // cout << ne << endl;
//             int x = -1;
//             REP(j,m){
//                 if (p[j] == ne){
//                     x = j;
//                     break;
//                 }
//             }
//             // cout << x << endl;
//             if (x < i - 3){
//                 ok = false;
//                 break;
//             }
//             FOR(j,x,i-1) appear[p[j]] = 1;
//             i = x;
//         }
//         ret += ok;
//         if (ok) {
//             if (st.count(p) == 0){
//                 REP(i,m) cout << p[i] << " ";
//                 cout << endl;
//             }
//         }
//     }while (next_permutation(ALL(p)));
//     return ret;
// }

ll mod;

int main(void){
    ll n;
    cin >> n >> mod;
    ll n3 = n * 3, ofs = n3, m = 2 * n3 + 10;
    VVL dp(n3 + 1, VL(m));
    dp[0][ofs] = 1;
    REP(i,n3) REP(j,m){
        if (dp[i][j] == 0) continue;
        ll r = n3 - i;
        (dp[i + 1][j + 1] += dp[i][j]) %= mod;
        if (r >= 2){
            (dp[i + 2][j - 1] += dp[i][j] * (r - 1)) %= mod;
        }
        if (r >= 3){
            ll x = ((r - 1) * (r - 2)) % mod;
            (dp[i + 3][j] += dp[i][j] * x) %= mod;
        }
    }
    // REP(i,n3+1){
    //     REP(j,2*n3) cout << dp[i][j] << " ";
    //     cout << endl;
    // }
    ll ans = 0;
    FOR(j,ofs,m-1) ans = (ans + dp[n3][j]) % mod;
    cout << ans << endl;

    return 0;
}


Measured memory_bytes: 563584