#include <bits/stdc++.h>
using namespace std;
template <int MOD> struct modint{
	static const int mod = MOD;
	int v;
	operator int() const {return v;} 
	modint():v(0) {}
	modint(long long _v):v(int(_v%MOD)) {v += (v<0)*MOD;}
	modint& operator+=(modint o) {if((v += o.v) >= MOD) v-= MOD; return *this;}
	modint& operator-=(modint o) {if((v -= o.v) < 0) v+= MOD; return *this;}
	modint& operator*=(modint o) {v = int((long long)v*o.v%MOD); return *this;}
	modint& operator/=(modint o) {return *this *= inv(o);}
	friend modint pow(modint a, long long p) {
		modint ans = 1; assert(p >= 0);
		for (; p; p /= 2, a *= a) if (p&1) ans *= a;
		return ans; }	friend modint inv(modint a) {assert(a.v != 0); return pow(a, MOD-2);}
	friend modint operator+(modint a, modint b) {return a += b;}
	friend modint operator-(modint a, modint b) {return a -= b;}
	friend modint operator*(modint a, modint b) {return a *= b;}
	friend modint operator/(modint a, modint b) {return a /= b;}
};
using mint = modint<(int)998244353>;

int main() {
    
    int n, pp;
    cin >> n >> pp;
    mint stay = (mint)pp * inv((mint)100);
    mint move = (mint)(100 - pp) * inv((mint)100);
    
    vector <int> arr(n + 1);
    for(int i = 1; i <= n; i++){
        cin >> arr[i];
    }
    
    mint home_prob = inv(mint(2 * n + 1));

    mint dp[2 * n + 1][2 * n + 1][2 * n + 1];
    for(int i = 0; i < 2 * n + 1; i++){
        for(int j = 0; j < 2 * n + 1; j++) {
            for(int k = 0; k < 2 * n + 1; k++) {
                dp[i][j][k] = 0;
            }
        }
        dp[i][n][0] = home_prob;
    }
    // dp[home][idx][time]

    mint answer = home_prob; // if home = n

    dp[n][n][0] = 0;


    for(int home = 0; home <= 2 * n; home++) {
        for(int time = 1; time <= n; time++) {
            for(int idx = 0; idx <= 2 * n; idx++) {
                dp[home][idx][time] += dp[home][idx][time - 1] * stay;
                if(idx > 0) {
                    if(arr[time] == 1) {
                        dp[home][idx][time] += dp[home][idx - 1][time - 1] * move;
                    }
                }
                if(idx < 2 * n) {
                    if(arr[time] == -1) {
                        dp[home][idx][time] += dp[home][idx - 1][time + 1] * move;
                    }
                }
                if(home == idx) {
                    answer += dp[home][idx][time];
                    dp[home][idx][time] = 0;
                }
            }
        } 
    }

    cout << ((int)answer) << endl;

}

/*

702764025

*/