#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

// если модуль подается на вход, убрать все <> и раскомментировать нужные строки
using uint = unsigned int;
using ull = unsigned long long;
template <uint MD> struct ModInt {
    using M = ModInt;
    // static int MD;
    uint v;
    ModInt(ll _v = 0) { set_v(uint(_v % MD + MD)); }
    M& set_v(uint _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    explicit operator bool() const { return v != 0; }
    M operator-() const { return M() - *this; }
    M operator+(const M& r) const { return M().set_v(v + r.v); }
    M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    M operator*(const M& r) const { return M().set_v(uint((ull)v * r.v % MD)); }
    M operator/(const M& r) const { return *this * r.inv(); }
    M& operator+=(const M& r) { return *this = *this + r; }
    M& operator-=(const M& r) { return *this = *this - r; }
    M& operator*=(const M& r) { return *this = *this * r; }
    M& operator/=(const M& r) { return *this = *this / r; }
    bool operator==(const M& r) const { return v == r.v; }
    bool operator!=(const M& r) const { return v != r.v; }
    M inv() const;
    friend istream& operator>>(istream& is, M& r) { ll x; is >> x; r = M(x); return is; }
    friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};

template<uint MD>
ModInt<MD> pow(ModInt<MD> x, ll n) {
    ModInt<MD> r = 1;
    while (n) {
        if (n & 1) r *= x;
        x *= x;
        n >>= 1;
    }
    return r;
}

template<uint MD>
ModInt<MD> ModInt<MD>::inv() const { return pow(*this, MD - 2); }
// or copy egcd and {return egcd(MD, v, 1).second;}

// if MD is from input
// this line is necessary, read later as you wish
// int ModInt::MD;

const int MOD = 998'244'353;
using Mint = ModInt<MOD>;
// using Mint = double;

#define V vector
void nft(bool type, V<Mint>& a) {
    Mint G = 3;
    int n = int(a.size()), s = 0;
    while ((1 << s) < n) s++;
    assert(1 << s == n);

    static V<Mint> ep, iep;
    while (int(ep.size()) <= s) {
        ep.push_back(pow(G, Mint(-1).v / (1 << ep.size())));
        iep.push_back(ep.back().inv());
    }
    V<Mint> b(n);
    for (int i = 1; i <= s; i++) {
        int w = 1 << (s - i);
        Mint base = type ? iep[i] : ep[i], now = 1;
        for (int y = 0; y < n / 2; y += w) {
            for (int x = 0; x < w; x++) {
                auto l = a[y << 1 | x];
                auto r = now * a[y << 1 | x | w];
                b[y | x] = l + r;
                b[y | x | n >> 1] = l - r;
            }
            now *= base;
        }
        swap(a, b);
    }
}

V<Mint> multiply_nft(const V<Mint>& a, const V<Mint>& b) {
    int n = int(a.size()), m = int(b.size());
    if (!n || !m) return {};
    if (min(n, m) <= 50) {
        V<Mint> ans(n + m - 1);
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++) ans[i + j] += a[i] * b[j];
        return ans;
    }
    int lg = 0;
    while ((1 << lg) < n + m - 1) lg++;
    int z = 1 << lg;
    auto a2 = a, b2 = b;
    a2.resize(z);
    b2.resize(z);
    nft(false, a2);
    nft(false, b2);
    for (int i = 0; i < z; i++) a2[i] *= b2[i];
    nft(true, a2);
    a2.resize(n + m - 1);
    Mint iz = Mint(z).inv();
    for (int i = 0; i < n + m - 1; i++) a2[i] *= iz;
    return a2;
}

struct rval {
    vector<Mint> values;
};

const int M = 1e5 + 239;

vector<Mint> base;

vector<Mint> pw[M];

void obtain(int s) {
    if (!pw[s].empty()) {
        return;
    }
    obtain(s / 2);
    obtain((s + 1) / 2);
    pw[s] = multiply_nft(pw[s / 2], pw[(s + 1) / 2]);
}

vector<Mint> func(int x1, int y1, int x2, int y2, vector<Mint>& val) {
    vector<Mint> ans(y2 + 1, 0);
    if (x2 == x1 + 1) {
        for (int y = 0; y <= y2; y++) {
            for (int dy = -2; dy <= 2; dy++) {
                if (y + dy >= 0 && y + dy <= y1) {
                    ans[y] += val[y + dy] * base[2 - dy];
                }
            }
        }
        return ans;
    }
    int len = (x2 - x1);
    if (y2 >= 2 * len) {
        obtain(len);
        auto res = multiply_nft(val, pw[len]);
        for (int i = 2 * len; i <= y2; i++) {
            if (i + 2 * len < (int)res.size()) {
                ans[i] = res[i + 2 * len];
            }
        }
    }
    int mid = (x1 + x2) / 2;

    int r_len = min(y2, 2 * len - 1);
    int mid_len = r_len + 2 * (x2 - mid);
    int l_len = min(y1, mid_len + 2 * (mid - x1));
    val.resize(l_len + 1);

    auto midvals = func(x1, l_len, mid, mid_len, val);
    auto rvals = func(mid, mid_len, x2, r_len, midvals);
    for (int i = 0; i <= r_len; i++) {
        ans[i] = rvals[i];
    }

    return ans;
}

Mint slow(int n, int m) {
    vector<Mint> dp(n + 2 * m + 1, 0);
    dp[n] = 1;
    for (int it = 0; it < m; it++) {
        vector<Mint> new_dp(dp.size(), 0);
        for (int y = 0; y < (int)dp.size(); y++) {
            for (int dy = -2; dy <= 2; dy++) {
                if (y + dy >= 0 && y + dy < (int)new_dp.size()) {
                    new_dp[y + dy] += dp[y] * base[2 + dy];
                }
            }
        }
        swap(dp, new_dp);
    }
    Mint ans = 0;
    for (const auto& t : dp) {
        ans += t;
    }
    return ans;
}

void solve() {
    int n, m;
    cin >> n >> m;

    if (m == 0) {
        cout << "1\n";
        return;
    }

    base.resize(5);
    Mint s = 0;
    for (int i = 0; i < 5; i++) {
        cin >> base[i];
        s += base[i];
    }
    for (int i = 0; i < 5; i++) {
        base[i] /= s;
    }

#ifdef ONPC
    if ((ll)(n + 2 * m) * (n + 2 * m) <= 1000000) {
        cout << slow(n, m) << "\n";
    }
#endif

    pw[1] = base;
    vector<Mint> vals(n + 1, 0);
    vals[n] = 1;
    auto res = func(0, n, m, n + 2 * m, vals);
    Mint ans = 0;
    for (const auto& t : res) {
        ans += t;
    }
    cout << ans << "\n";
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }

    cerr << TIME << "\n";

    return 0;
}