#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,n) for(int i=0;i<n;i++)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define rrep2(i,n,k) for(int i=n-1;i>=n-k;i--)
#define vll(n,i) vector<long long>(n,i)
#define v2ll(n,m,i) vector<vector<long long>>(n,vll(m,i))
#define v3ll(n,m,k,i) vector<vector<vector<long long>>>(n,v2ll(m,k,i))
#define v4ll(n,m,k,l,i) vector<vector<vector<vector<long long>>>>(n,v3ll(m,k,l,i))
#define all(v) v.begin(),v.end()
#define chmin(k,m) k = min(k,m)
#define chmax(k,m) k = max(k,m)
#define Pr pair<ll,ll>
#define Tp tuple<int,int,int>
#define riano_ std::ios::sync_with_stdio(false);std::cin.tie(nullptr)
using Graph = vector<vector<int>>;

const ll mod = 998244353;
template<uint64_t mod>
struct modint{
    uint64_t val;
    constexpr modint(const int64_t val_=0) noexcept:val((val_%int64_t(mod)+int64_t(mod))%int64_t(mod)){}
    constexpr modint operator-() const noexcept{
        return modint(*this)=mod-val;
    }
    constexpr modint operator+(const modint rhs) const noexcept{
        return modint(*this)+=rhs;
    }
    constexpr modint operator-(const modint rhs) const noexcept{
        return modint(*this)-=rhs;
    }
    constexpr modint operator*(const modint rhs) const noexcept{
        return modint(*this)*=rhs;
    }
    constexpr modint operator/(const modint rhs) const noexcept{
        return modint(*this)/=rhs;
    }
    constexpr modint &operator+=(const modint rhs) noexcept{
        val+=rhs.val;
        val-=((val>=mod)?mod:0);
        return (*this);
    }
    constexpr modint &operator-=(const modint rhs) noexcept{
        val+=((val<rhs.val)?mod:0);
        val-=rhs.val;
        return (*this);
    }
    constexpr modint &operator*=(const modint rhs) noexcept{
        val=val*rhs.val%mod;
        return (*this);
    }
    constexpr modint &operator/=(modint rhs) noexcept{
        uint64_t ex=mod-2;
        modint now=1;
        while(ex){
            now*=((ex&1)?rhs:1);
            rhs*=rhs,ex>>=1;
        }
        return (*this)*=now;
    }
    modint & operator++(){
        val++;
        if (val == mod) val = 0;
        return *this;
    }
    modint operator++(int){
        modint<mod> res = *this;
        ++*this;
        return res;
    }
    constexpr bool operator==(const modint rhs) noexcept{
        return val==rhs.val;
    }
    constexpr bool operator!=(const modint rhs) noexcept{
        return val!=rhs.val;
    }
    friend constexpr ostream &operator<<(ostream& os,const modint x) noexcept{
        return os<<(x.val);
    }
    friend constexpr istream &operator>>(istream& is,modint& x) noexcept{
        uint64_t t;
        is>>t,x=t;
        return is;
    }
};
typedef modint<mod> mint;
#define vm(n,i) vector<mint>(n,i)
#define v2m(n,m,i) vector<vector<mint>>(n,vm(m,i))
#define v3m(n,m,k,i) vector<vector<vector<mint>>>(n,v2m(m,k,i))
#define v4m(n,m,k,l,i) vector<vector<vector<vector<mint>>>>(n,v3m(m,k,l,i))


//累乗 aのb乗、正しmを法として求める
long long pw(long long a,long long b,long long m){
    if(b==0) return 1;
    else if(b%2==0){
        long long x = pw(a,b/2,m);
        return (x*x)%m;
    }
    else{
        long long x = pw(a,b-1,m);
        return (a*x)%m;
    }
}


mint sum_r(mint a,mint r, mint n){
    if(n==0) return mint(0);
    mint res = a*mint(pw(r.val,n.val,mod)-1)/(r-mint(1));
    return res;
}


//Combination2
//10^6くらいまで
//modはグローバルに定義しておく
long long modinv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while (b) {
        long long t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}
vector<ll> fact;
vector<ll> invf;
ll comb(ll n,ll k){
    if(n<0||k<0||k>n) return 0LL;
    else{
        ll a = fact[n]*invf[k]%mod;
        a = a*invf[n-k]%mod;
        return a;
    }
}
    

// 最大公約数を求める
ll gcd(ll x,ll y){
    ll r=1;
    if(x<0) x *= -1;
    if(y<0) y *= -1;
    if(x<=y) swap(x,y);
    if(y==0) r=0;
    while(r>0){
        r=x%y;
        x=y;
        y=r;
    }
    return x;
}

int main() {
    riano_; ll ans = 0;
    ll H,W,M; cin >> H >> W >> M;
    if(W==1){
        cout << 1 << endl; return 0;
    }
    ll dp[H][W];
    rep(i,H){
        rep(j,W){
            dp[i][j] = 0;
        }
    }
    rep(j,W) dp[0][j] = 1;
    if(H%2!=0){
        cout << 0 << endl; return 0;
    }
    rep(i,H-1){
        rep(j,W){
            if(i%2==0){
                if(W%2!=0){
                    if(j%2!=0) continue;
                    for(int k=2;k<W-1;k+=2){
                        if(k==j) continue;
                        dp[i+1][k] += dp[i][j];
                        dp[i+1][k] %= M;
                    }
                    dp[i+1][0] += dp[i][j];
                    dp[i+1][W-1] += dp[i][j];
                }
                else{
                    if(j%2==0){
                        for(int k=j+1;k<W;k+=2){
                            dp[i+1][k] += dp[i][j];
                            dp[i+1][k] %= M;
                        }
                    }
                    else{
                        for(int k=j-1;k>=0;k-=2){
                            dp[i+1][k] += dp[i][j];
                            dp[i+1][k] %= M;
                        }
                    }
                }
            }
            else{
                if(j==0){
                    dp[i+1][0] += dp[i][j]; dp[i+1][0] %= M;
                    dp[i+1][1] += dp[i][j]; dp[i+1][1] %= M;
                }
                else if(j==W-1){
                    dp[i+1][W-1] += dp[i][j]; dp[i+1][W-1] %= M;
                    dp[i+1][W-2] += dp[i][j]; dp[i+1][W-2] %= M;
                }
                else{
                    dp[i+1][j-1] += dp[i][j]; dp[i+1][j-1] %= M;
                    dp[i+1][j] += dp[i][j]; dp[i+1][j] %= M;
                    dp[i+1][j+1] += dp[i][j]; dp[i+1][j+1] %= M;
                }
            }
        }
    }
    rep(i,W){
        ans += dp[H-1][i];
    }
    cout << ans%M << endl;
}