#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  for (auto i = begin(v); i != end(v); i++)
    os << *i << (i == end(v) - 1 ? "" : " ");
  return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
  for (auto i = begin(v); i != end(v); i++) is >> *i;
  return is;
}
template <int mod>
class ModNum {
 private:
  int num;
  inline int easy_mod(int value) const {
    while (value > mod) value -= mod;
    return value;
  }

 public:
  ModNum(const int value) : num(value) {
    if (num < 0)
      num += mod * (-num / mod + 1);
    else if (num > mod)
      num = num % mod;
  }
  operator int() const { return num; }
  ModNum& operator=(const ModNum<mod>& rhs) {
    this->num = rhs.num;
    return *this;
  }
  ModNum operator+(const ModNum& rhs) const {
    return ModNum(easy_mod(rhs.num + num));
  }
  ModNum operator+(const int& val) const { return ModNum(num + val); }
  ModNum& operator+=(const ModNum& rhs) {
    this->num = easy_mod(num + rhs.num);
    return *this;
  }
  ModNum operator-(const ModNum& rhs) const {
    return ModNum(easy_mod(num + mod - rhs.num));
  }
  ModNum& operator-=(const ModNum& rhs) {
    this->num = easy_mod(num + mod - rhs.num);
    return *this;
  }
  ModNum operator*(const int& rhs) const {
    long long x = (long long)num * rhs;
    return ModNum(x < mod ? x : (x % mod));
  }
  ModNum& operator*=(const int& rhs) {
    long long x = (long long)num * rhs;
    this->num = x < mod ? (int)x : (x % mod);
    return *this;
  }
  ModNum operator/(const ModNum& rhs) const { return div(rhs); }
  ModNum operator/(const int rhs) const { return div(rhs); }
  ModNum div(const ModNum& other) const {
    return (*this) * (other.pow(mod - 2));
  }
  ModNum div(const int& other) const { return div(ModNum(other)); }
  inline ModNum pow(const unsigned long long power) const {
    ModNum resp = 1;
    unsigned long long power2_value = 1;
    ModNum power2_mod = *this;
    while (power2_value <= power) {
      if (power & power2_value) resp *= power2_mod;
      power2_mod *= power2_mod;
      power2_value *= 2ULL;
    }
    return resp;
  }
  inline ModNum pow(const int power) const {
    return this->pow((const unsigned long long)power);
  }
};
template <int mod>
ModNum<mod> pow(ModNum<mod> base, int power) {
  return base.pow(power);
}
int n, q;
vector<ModNum<998244353> > prefixes;
vector<ModNum<998244353> > multiples;
ModNum<998244353> get_range(int from, int to) {
  to--;
  ModNum<998244353> ret = prefixes[to];
  if (from > 0) {
    ret -= prefixes[from - 1] * (multiples[to] / multiples[from - 1]);
  }
  return ret;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> q;
  vector<int> ps(n);
  cin >> ps;
  prefixes.push_back(ModNum<998244353>(100) / ps[0]);
  multiples.push_back(prefixes.back());
  for (int i = 1; i < n; i++) {
    ModNum<998244353> x = ModNum<998244353>(100) / ps[i];
    multiples.push_back(multiples.back() * x);
    prefixes.push_back((prefixes.back() + 1) * x);
  }
  set<int> checkpoints;
  checkpoints.insert(0);
  checkpoints.insert(n);
  ModNum<998244353> current_answer = get_range(0, n);
  for (int i = 0; i < q; i++) {
    int pt;
    cin >> pt;
    pt--;
    auto above = checkpoints.upper_bound(pt);
    auto below = checkpoints.lower_bound(pt);
    below--;
    if (checkpoints.find(pt) == checkpoints.end()) {
      current_answer -= get_range(*below, *above);
      current_answer += get_range(*below, pt);
      current_answer += get_range(pt, *above);
      checkpoints.insert(pt);
    } else {
      current_answer += get_range(*below, *above);
      current_answer -= get_range(*below, pt);
      current_answer -= get_range(pt, *above);
      checkpoints.erase(pt);
    }
    cout << current_answer << "\n";
  }
  return 0;
}
