#include <bits/stdc++.h>
using namespace std;

int io_=[](){ ios::sync_with_stdio(false); cin.tie(nullptr); return 0; }();

using LL = long long;
using ULL = unsigned long long;
using LD = long double;
using PII = pair<int, int>;
using VI = vector<int>;
using MII = map<int, int>;

template<typename T> void cmin(T &x,const T &y) { if(y<x) x=y; }
template<typename T> void cmax(T &x,const T &y) { if(x<y) x=y; }
template<typename T> bool ckmin(T &x,const T &y) { 
    return y<x ? (x=y, true) : false; }
template<typename T> bool ckmax(T &x,const T &y) { 
    return x<y ? (x=y, true) : false; }
template<typename T> void cmin(T &x,T &y,const T &z) {// x<=y<=z 
    if(z<x) { y=x; x=z; } else if(z<y) y=z; }
template<typename T> void cmax(T &x,T &y,const T &z) {// x>=y>=z
    if(x<z) { y=x; x=z; } else if(y<z) y=z; }

// mt19937 rnd(chrono::system_clock::now().time_since_epoch().count());
// mt19937_64 rnd_64(chrono::system_clock::now().time_since_epoch().count());
template<long long Mo=998244353> struct ModInt {
  static long long MO;
  static void setMo(long long mo) { MO = mo; }
  long long x;
  ModInt(long long x=0) : x(x){ norm(); }
  friend istream &operator>>(istream& in, ModInt &B) { in>>B.x; return in; }
  friend ostream &operator<<(ostream& out, const ModInt &B) { 
    out<<B.x; return out; }
  // ModInt operator=(int x_) { x=x_; norm(); return *this; }
  void norm() { x = (x%MO + MO) % MO; }
  long long get() { return x; }

  ModInt operator-() const { return ModInt(MO - x); }
  ModInt operator+=(const ModInt &B) { x+=B.x; if(x>=MO) x-=MO; return *this; }
  ModInt operator-=(const ModInt &B) { x-=B.x; if(x<0) x+=MO; return *this; }
  ModInt operator*=(const ModInt &B) { x=x*B.x%MO; return *this; }
  ModInt operator+(const ModInt &B) const { ModInt ans=*this; return ans+=B; }
  ModInt operator-(const ModInt &B) const { ModInt ans=*this; return ans-=B; }
  ModInt operator*(const ModInt &B) const { ModInt ans=*this; return ans*=B; }
  ModInt operator^(long long n) const  {
    ModInt a=*this; ModInt ans(1);
    while(n) { if(n&1) ans*=a; a*=a; n>>=1; }
    return ans;
  }
  ModInt inv() const { return (*this)^(MO-2); } // if MO is prime
  ModInt operator/=(const ModInt &B) { (*this)*=B.inv(); return *this; }
  ModInt operator/(const ModInt &B) const { ModInt ans=*this; return ans/=B; }

  bool operator<(const ModInt &B) const { return x<B.x; }
  bool operator==(const ModInt &B) const { return x==B.x; }
  bool operator!=(const ModInt &B) const { return x!=B.x; }
};
template<long long Mo> long long ModInt<Mo>::MO = Mo;
typedef ModInt<998244353> Mint;
// typedef ModInt<1'000'000'007> Mint;

template<typename T> struct GetZero { T operator()() const { return T(0); } };
template<typename T,
         typename OpPlus=plus<T>,typename OpMinus=minus<T>,
         typename Zero=GetZero<T> >
struct BIT {
  static int lowbit(int x) { return x&(-x); }
  constexpr static OpPlus opp{};
  constexpr static OpMinus opm{};
  constexpr static Zero zero{};
  int n;
  vector<T> tree; // tree[i] -> sum of [i-lowbit(i)+1,i]
  BIT(int n_=0):n(n_),tree(n+1,zero()) {}
  void init(int n_) { n=n_; tree.assign(n+1,zero()); }
  void init(const vector<T> &vec) { // v[0 ~ n_-1]
    n=vec.size();
    vector<T> tmp(n+1,zero());
    for(int i=1;i<=n;i++) tmp[i]=opp(tmp[i-1],vec[i-1]);
    for(int i=1;i<=n;i++) tree[i]=opm(tmp[i],tmp[i-lowbit(i)]);
  }
  void add(int p,T v) { 
    for(;p<=n;p+=lowbit(p)) tree[p]=opp(tree[p],v);
  }
  T sum(int p) {
    T ans=zero();
    for(;p;p-=lowbit(p)) ans=opp(ans,tree[p]);
    return ans;
  }
  T sum(int l,int r) { return opm(sum(r),sum(l-1)); }
};
/*
---------1---------2---------3---------4---------5---------6---------7---------
1234567890123456789012345678901234567890123456789012345678901234567890123456789
*/

const int M = 2e5 + 5;
vector<Mint> pw2;
void init() {
  pw2.assign(M, 1);
  for (int i = 1; i < M; i++) {
    pw2[i] = pw2[i - 1] * 2;
  }
}

void solve() {
  string s; cin >> s;
  int n = s.length();

  vector<BIT<Mint>> bit(4, BIT<Mint>(n));
  Mint ans = 0;

  for (int i = 0; i < n; i++) {
    int v = s[i] - '0';
    bit[v << 1].add(i + 1, pw2[i]);
    bit[v << 1 | 1].add(i + 1, pw2[n - i - 1]);
  }

  for (int i = 1; i < n; i++) {
    int v = (s[i] - '0') ^ 1;
    ans += bit[v << 1].sum(i) * pw2[n - i - 1];
  }

  ans += pw2[n] - 1;

  // cerr << ans << '\n';

  int q; cin >> q;
  int vi;
  for (int i = 0; i < q; i++) {
    cin >> vi; vi--;
    int v = s[vi] - '0';
    if (vi) ans -= bit[(v ^ 1) << 1].sum(vi) * pw2[n - vi - 1];
    if (vi + 1 < n) ans -= bit[(v ^ 1) << 1 | 1].sum(vi + 1, n) * pw2[vi];
    bit[v << 1].add(vi + 1, -pw2[vi]);
    bit[v << 1 | 1].add(vi + 1, -pw2[n - vi - 1]);


    if (vi) ans += bit[v << 1].sum(vi) * pw2[n - vi - 1];
    if (vi + 1 < n) ans += bit[v << 1 | 1].sum(vi + 1, n) * pw2[vi];
    bit[(v ^ 1) << 1].add(vi + 1, pw2[vi]);
    bit[(v ^ 1) << 1 | 1].add(vi + 1, pw2[n - vi - 1]);

    if (s[vi] == '1') s[vi] = '0';
    else s[vi] = '1';

    cout << ans << (" \n"[i == q - 1]);
  }

}

int main() {
  init();
  int t = 1; 
  cin >> t;
  while (t--) {
    solve();
  }
  return 0;
}