#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void outarr(Tp _begin, Tp _end, const char* _delim = " ") {
  for (Tp current = _begin; current != _end; ++current) {
    std::cout << *current << _delim;
  }
  std::cout << '\n';
}
using ll = long long;
using pii = std::pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr int MOD = static_cast<const int>(1e9 + 7);
constexpr int g_mod = 998244353;
constexpr int MAXN = 200000;
class SegmentTree {
 public:
  struct Node {
    int Val = 0;
    int Push = -1;
  };
  explicit SegmentTree(int n) : size(n), tree(size << 2) {}
  void Update(int l, int r, int x) { UpdateImpl(0, 0, size - 1, l, r, x); }
  int Get(int i) { return GetImpl(0, 0, size - 1, i); }

 private:
  int Left(int v) const { return (v << 1) + 1; }
  int Right(int v) const { return (v << 1) + 2; }
  void Modify(int v, int x) {
    tree[v].Val = x;
    tree[v].Push = x;
  }
  void Push(int v) {
    if (tree[v].Push != -1) {
      for (int u : {Left(v), Right(v)}) {
        Modify(u, tree[v].Push);
      }
      tree[v].Push = -1;
    }
  }
  void UpdateImpl(int v, int tl, int tr, int l, int r, int x) {
    if (l > r) {
      return;
    }
    if (tl == l && r == tr) {
      Modify(v, x);
      return;
    }
    Push(v);
    int mid = (tl + tr) >> 1;
    UpdateImpl(Left(v), tl, mid, l, min(mid, r), x);
    UpdateImpl(Right(v), mid + 1, tr, max(mid + 1, l), r, x);
  }
  int GetImpl(int v, int tl, int tr, int i) {
    if (tl == tr) {
      return tree[v].Val;
    }
    Push(v);
    int mid = (tl + tr) >> 1;
    if (i <= mid) {
      return GetImpl(Left(v), tl, mid, i);
    }
    return GetImpl(Right(v), mid + 1, tr, i);
  }
  int size;
  vector<Node> tree;
};
int inv[101];
int prob[MAXN];
int inv_p[MAXN];
bool is_checkpoint[MAXN];
int pref[MAXN];
int Add(int x, int y) {
  x += y;
  return x < g_mod ? x : x - g_mod;
}
int Sub(int x, int y) {
  x -= y;
  return x >= 0 ? x : x + g_mod;
}
int Mul(int x, int y) { return int(1LL * x * y % g_mod); }
int FastPow(int x, int p) {
  int res = 1;
  while (p > 0) {
    if (p & 1) {
      res = Mul(res, x);
    }
    p >>= 1;
    x = Mul(x, x);
  }
  return res;
}
int Inv(int x) { return FastPow(x, g_mod - 2); }
void Init() {
  is_checkpoint[0] = true;
  for (int i = 1; i <= 100; ++i) {
    inv[i] = Inv(i);
  }
}
namespace st {
int tree[MAXN << 2];
int tree_push[MAXN << 2];
int Left(int v) { return (v << 1) + 1; }
int Right(int v) { return (v << 1) + 2; }
void UpdateVertex(int v) { tree[v] = Add(tree[Left(v)], tree[Right(v)]); }
void Modify(int v, int x) {
  tree[v] = Mul(tree[v], x);
  tree_push[v] = Mul(tree_push[v], x);
}
void Push(int v) {
  if (tree_push[v] != 1) {
    for (int u : {Left(v), Right(v)}) {
      Modify(u, tree_push[v]);
    }
    tree_push[v] = 1;
  }
}
void BuildImpl(int v, int tl, int tr, int* arr) {
  tree_push[v] = 1;
  if (tl == tr) {
    tree[v] = *(arr + tl);
    return;
  }
  int mid = (tl + tr) >> 1;
  BuildImpl(Left(v), tl, mid, arr);
  BuildImpl(Right(v), mid + 1, tr, arr);
  UpdateVertex(v);
}
void Build(int* arr, int n) { BuildImpl(0, 0, n - 1, arr); }
void UpdateImpl(int v, int tl, int tr, int l, int r, int x) {
  if (l > r) {
    return;
  }
  if (tl == l && r == tr) {
    Modify(v, x);
    return;
  }
  Push(v);
  int mid = (tl + tr) >> 1;
  UpdateImpl(Left(v), tl, mid, l, min(mid, r), x);
  UpdateImpl(Right(v), mid + 1, tr, max(mid + 1, l), r, x);
  UpdateVertex(v);
}
void Update(int l, int r, int x, int n) { UpdateImpl(0, 0, n - 1, l, r, x); }
int Query() { return tree[0]; }
int Query(int v, int tl, int tr, int l, int r) {
  if (l > r) {
    return 0;
  }
  if (tl == l && r == tr) {
    return tree[v];
  }
  Push(v);
  int mid = (tl + tr) >> 1;
  return Add(Query(Left(v), tl, mid, l, min(mid, r)),
             Query(Right(v), mid + 1, tr, max(mid + 1, l), r));
}
}  // namespace st
int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  Init();
  int n, q;
  cin >> n >> q;
  for (int i = 0; i < (n); ++i) {
    cin >> prob[i];
    inv_p[i] = Mul(100, inv[prob[i]]);
    prob[i] = Mul(prob[i], inv[100]);
  }
  int curp = 1;
  for (int i = n - 1; i >= 0; --i) {
    curp = Mul(curp, inv_p[i]);
    pref[i] = curp;
  }
  SegmentTree head(n);
  SegmentTree tail(n);
  tail.Update(0, n - 1, n - 1);
  st::Build(pref, n);
  while (q--) {
    int j;
    cin >> j;
    --j;
    is_checkpoint[j] ^= true;
    if (is_checkpoint[j]) {
      int h = head.Get(j);
      int t = tail.Get(j);
      head.Update(j, t, j);
      tail.Update(h, j - 1, j - 1);
      st::Update(h, j - 1, Inv(st::Query(0, 0, n - 1, j, j)), n);
    } else {
      int h = head.Get(j - 1);
      int t = tail.Get(j);
      head.Update(j, t, h);
      tail.Update(h, j - 1, t);
      st::Update(h, j - 1, st::Query(0, 0, n - 1, j, j), n);
    }
    cout << st::Query() << "\n";
  }
  return 0;
}
