#include <bits/stdc++.h>
using namespace std;
const int N = 210000, K = N << 2, mod = 998244353;
int n, q, p[N], inv;
struct matrix {
  long long c[3][3];
  matrix(int k = 0) {
    memset(c, 0, sizeof(c));
    if (k) c[0][0] = c[1][1] = c[2][2] = 1;
    return;
  }
  inline matrix operator*(const matrix &x) const {
    matrix ret;
    for (register int i = 0; i <= 2; ++i)
      for (register int j = 0; j <= 2; ++j) {
        for (register int k = 0; k <= 2; ++k)
          ret.c[i][j] += c[i][k] * x.c[k][j];
        ret.c[i][j] %= mod;
      }
    return ret;
  }
} base;
set<int> app;
inline long long quickpow(long long base, long long pw) {
  long long ret = 1;
  while (pw) {
    if (pw & 1) ret = ret * base % mod;
    base = base * base % mod, pw >>= 1;
  }
  return ret;
}
template <class T>
inline void read(T &x) {
  x = 0;
  char ch = getchar(), w = 0;
  while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
  while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
  x = w ? -x : x;
  return;
}
struct segmentTree {
  int lt[K], rt[K];
  matrix data[K];
  inline void init() {
    lt[1] = 1, rt[1] = n, build(1);
    return;
  }
  void build(int k) {
    if (lt[k] == rt[k]) {
      data[k].c[0][0] = (long long)p[lt[k]] * inv % mod, data[k].c[0][2] = 1,
      data[k].c[2][2] = 1;
      data[k].c[1][1] = data[k].c[0][0],
      data[k].c[1][2] = mod + 1 - data[k].c[1][1];
      return;
    }
    lt[(k << 1)] = lt[k], rt[(k << 1)] = ((lt[k] + rt[k]) >> 1),
             lt[(k << 1 | 1)] = ((lt[k] + rt[k]) >> 1) + 1,
             rt[(k << 1 | 1)] = rt[k];
    build((k << 1)), build((k << 1 | 1)),
        data[k] = data[(k << 1)] * data[(k << 1 | 1)];
    return;
  }
  inline matrix query(int k, int x, int y) {
    if (y < x) return matrix(1);
    if (lt[k] >= x && rt[k] <= y) return data[k];
    if (x <= ((lt[k] + rt[k]) >> 1) && y > ((lt[k] + rt[k]) >> 1))
      return query((k << 1), x, y) * query((k << 1 | 1), x, y);
    return query(x <= ((lt[k] + rt[k]) >> 1) ? (k << 1) : (k << 1 | 1), x, y);
  }
} seg;
inline long long calc(int x, int y) {
  matrix tmp = seg.query(1, x + 1, y) * base;
  return (100 * quickpow(p[x] * (mod + 1 - tmp.c[1][0]) % mod, mod - 2) +
          tmp.c[0][0] * quickpow(mod + 1 - tmp.c[1][0], mod - 2)) %
         mod;
}
int main() {
  int x;
  read(n), read(q);
  inv = quickpow(100, mod - 2);
  for (register int i = 1; i <= n; ++i) read(p[i]);
  app.insert(1), app.insert(n + 1);
  seg.init(), base.c[2][0] = 1;
  long long ans = calc(1, n);
  while (q--) {
    read(x);
    auto it = app.lower_bound(x);
    if (*it == x) {
      ans = (ans + calc(*prev(it), *next(it) - 1) - calc(*prev(it), x - 1) -
             calc(x, *next(it) - 1) + 2 * mod) %
            mod;
      app.erase(it);
    } else {
      ans = (ans - calc(*prev(it), *it - 1) + calc(*prev(it), x - 1) +
             calc(x, *it - 1) + mod) %
            mod;
      app.insert(x);
    }
    printf("%lld\n", ans);
  }
  return 0;
}
