#include<bits/stdc++.h>
using namespace std;

#define V vector
#define pb push_back
#define fi first
#define se second
#define all0(x) (x).begin(), (x).end()
#define all1(x) (x).begin() + 1, (x).end()

typedef long long LL;
typedef pair<int, int> pi;

mt19937 mrand(chrono::steady_clock().now().time_since_epoch().count());

int mod;
LL MOD(LL x) {
    if(x >= mod) return x- mod;
    if(x < 0) return x + mod;
    return x;
}

LL qpow(LL x, LL k) {
    LL ans =1 ;
    while(k) {
        if(k & 1) ans = x * ans % mod;
        k >>= 1;
        x = x * x % mod;
    }
    return ans;
}
int n;
const int N = 101;
int ans[N], hav[N];

LL deal_dp(int t, int sum) {
    // cout << "t, sum : " << t << " " << sum << endl;
    V<V<LL>> dp(n * 2 + 1, V<LL>(2));
    V<V<LL>> n_dp(n * 2 + 1, V<LL>(2));
    dp[n][0] = 1;
    int lo = 2 - sum;   
    for(int i = 1; i <= n; i++) {
        for(auto &v : n_dp) for(auto &x : v) x = 0;
        for(int j = -n; j <= n; j++) {
            //
            int l = lo + j, r = j + 2;
            l = max(-n, l);
            //0->0
            if(l <= n) n_dp[l + n][0] = MOD(n_dp[l + n][0] + dp[j + n][0]);
            if(r <= n) n_dp[r + n][0] = MOD(n_dp[r + n][0] - dp[j + n][0]);
            //1->1
            if(l <= n) n_dp[l + n][1] = MOD(n_dp[l + n][1] + dp[j + n][1]);
            if(r <= n) n_dp[r + n][1] = MOD(n_dp[r + n][1] - dp[j + n][1]);

            l = j + -t, r = lo - 1 + j + 1;
            l = max(-n, l);
            // cout << "i, j, l, r : " << i << " " << j << " " << l << " " << r << endl;
            if(l <= r) {
                //0->1
                if(l <= n) n_dp[l + n][1] = MOD(n_dp[l + n][1] + dp[j + n][0]);
                if(r <= n) n_dp[r + n][1] = MOD(n_dp[r + n][1] - dp[j + n][0]);
                //1->1
                if(l <= n) n_dp[l + n][1] = MOD(n_dp[l + n][1] + dp[j + n][1]);
                if(r <= n) n_dp[r + n][1] = MOD(n_dp[r + n][1] - dp[j + n][1]);
            }
        }
        for(int i = 1; i < n_dp.size(); i++) {
            n_dp[i][0] = MOD(n_dp[i][0] + n_dp[i - 1][0]);
            n_dp[i][1] = MOD(n_dp[i][1] + n_dp[i - 1][1]);
        }
        swap(dp, n_dp);
        // cout << "dp , i : " << i << endl;
        // for(int i = -n; i <= n; i++) cout << dp[n + i][0] << " ";
        // cout << endl;
        // for(int i = -n; i <= n; i++) cout << dp[i + n][1] << " ";
        // cout << endl;
    } 
    return dp[sum + n][1];
}

LL cal_t(int t) {
    if(hav[t]) return ans[t];
    //
    for(int sum = 1; sum <= n; sum++) {
        ans[t] = MOD(ans[t] + deal_dp(t, sum));
        // cout << "t, sum, dp : " << t << " " << sum << " " << deal_dp(t, sum) << endl;
    }
    hav[t] = 1;
    return ans[t];
}


void solve(){
    int m; cin >> n >> m;
    cin >> mod;
    LL ans = 0;
    ans = qpow(2 * m + 1, n);
    // cout << "ans : " << ans << endl;
    for(int x = 1; x <= m; x++) {
        ans -= 2 * cal_t(m / x);    
    }
    ans = MOD(ans % mod);
    // cout << "ans : " << ans << endl;


    int tot = n * m;

    V<LL> dp(2 * tot + 1);
    auto n_dp = dp;
    dp[tot] = 1;
    for(int i = 1; i <= n; i++) {
        for(auto &x : n_dp) x = 0;
        for(int j = -tot; j <= tot; j++) {
            if(dp[tot + j] == 0) continue;
            for(int k = j - m; k <= j + m; k++) {
                n_dp[tot + k] = MOD(n_dp[tot + k] + dp[tot + j]);
            }
        }
        dp = n_dp;
    }
    ans = MOD(ans - dp[tot]);
    // cout << "ans : " << ans << endl;
    cout << ans << "\n";

}
int main() {
    // ios::sync_with_stdio(0),cin.tie(0);
    // int t; cin >> t;
    // while(t--) 
        solve();
}