#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}


constexpr Int bmds(Int x){
  const Int v[] = {1012924417, 924844033, 998244353,
                   897581057, 645922817};
  return v[x];
}
constexpr Int brts(Int x){
  const Int v[] = {5, 5, 3, 3, 3};
  return v[x];
}


template<Int X>
struct NTT{
  static constexpr Int md = bmds(X);
  static constexpr Int rt = brts(X);

  inline Int add(Int a,Int b){
    a+=b;
    if(a>=md) a-=md;
    return a;
  }

  inline Int mul(Int a,Int b){
    return 1LL*a*b%md;
  }

  inline Int pow(Int a,Int b){
    Int res=1;
    while(b){
      if(b&1) res=mul(res,a);
      a=mul(a,a);
      b>>=1;
    }
    return res;
  }

  inline Int inv(Int x){
    return pow(x,md-2);
  }

  // assume md % 4 = 1
  // if md % 4 == 3, then x = a^{(md+1)/4}
  inline Int sqrt(Int a){
    if(a==0) return 0;
    if(pow(a,(md-1)/2)!=1) return -1;
    Int q=md-1,m=0;
    while(~q&1) q>>=1,m++;
    mt19937 mt;
    Int z=mt()%md;
    while(pow(z,(md-1)/2)!=md-1) z=mt()%md;
    Int c=pow(z,q),t=pow(a,q),r=pow(a,(q+1)/2);
    while(m>1){
      if(pow(t,1<<(m-2))!=1)
        r=mul(r,c),t=mul(t,mul(c,c));
      c=mul(c,c);
      m--;
    }
    return r;
  }

  vector<vector<Int> > rts,rrts;

  void ensure_base(Int n){
    if((Int)rts.size()>=n) return;
    rts.resize(n);rrts.resize(n);
    for(Int i=1;i<n;i<<=1){
      if(!rts[i].empty()) continue;
      Int w=pow(rt,(md-1)/(i<<1));
      Int rw=inv(w);
      rts[i].resize(i);rrts[i].resize(i);
      rts[i][0]=1;rrts[i][0]=1;
      for(Int k=1;k<i;k++){
        rts[i][k]=mul(rts[i][k-1],w);
        rrts[i][k]=mul(rrts[i][k-1],rw);
      }
    }
  }

  void ntt(vector<Int> &a,bool f,Int n=-1){
    if(n==-1) n=a.size();
    assert((n&(n-1))==0);

    for(Int i=0,j=1;j+1<n;j++){
      for(Int k=n>>1;k>(i^=k);k>>=1);
      if(i>j) swap(a[i],a[j]);
    }

    for(Int i=1;i<n;i<<=1){
      for(Int j=0;j<n;j+=i*2){
        for(Int k=0;k<i;k++){
          Int z=mul(a[i+j+k],f?rrts[i][k]:rts[i][k]);
          a[i+j+k]=add(a[j+k],md-z);
          a[j+k]=add(a[j+k],z);
        }
      }
    }

    if(f){
      Int tmp=inv(n);
      for(Int i=0;i<n;i++) a[i]=mul(a[i],tmp);
    }
  }

  vector<Int> add(vector<Int> as,vector<Int> bs){
    Int sz=max(as.size(),bs.size());
    vector<Int> cs(sz,0);
    for(Int i=0;i<(Int)as.size();i++) cs[i]=add(cs[i],as[i]);
    for(Int i=0;i<(Int)bs.size();i++) cs[i]=add(cs[i],bs[i]);
    return cs;
  }

  vector<Int> sub(vector<Int> as,vector<Int> bs){
    Int sz=max(as.size(),bs.size());
    vector<Int> cs(sz,0);
    for(Int i=0;i<(Int)as.size();i++) cs[i]=add(cs[i],as[i]);
    for(Int i=0;i<(Int)bs.size();i++) cs[i]=add(cs[i],md-bs[i]);
    return cs;
  }

  vector<Int> multiply(vector<Int> as,vector<Int> bs){
    Int need=as.size()+bs.size()-1;
    Int sz=1;
    while(sz<need) sz<<=1;
    ensure_base(sz);

    vector<Int> f(sz),g(sz);
    for(Int i=0;i<(Int)as.size();i++) f[i]=as[i];
    for(Int i=0;i<(Int)bs.size();i++) g[i]=bs[i];
    ntt(f,0);ntt(g,0);
    for(Int i=0;i<sz;i++) f[i]=mul(f[i],g[i]);
    ntt(f,1);

    f.resize(need);
    return f;
  }
};


template<typename T,T MOD = 1000000007>
struct Mint{
  static constexpr T mod = MOD;
  T v;
  Mint():v(0){}
  Mint(signed v):v(v){}
  Mint(long long t){v=t%MOD;if(v<0) v+=MOD;}

  Mint pow(long long k){
    Mint res(1),tmp(v);
    while(k){
      if(k&1) res*=tmp;
      tmp*=tmp;
      k>>=1;
    }
    return res;
  }

  static Mint add_identity(){return Mint(0);}
  static Mint mul_identity(){return Mint(1);}

  Mint inv(){return pow(MOD-2);}

  Mint& operator+=(Mint a){v+=a.v;if(v>=MOD)v-=MOD;return *this;}
  Mint& operator-=(Mint a){v+=MOD-a.v;if(v>=MOD)v-=MOD;return *this;}
  Mint& operator*=(Mint a){v=1LL*v*a.v%MOD;return *this;}
  Mint& operator/=(Mint a){return (*this)*=a.inv();}

  Mint operator+(Mint a) const{return Mint(v)+=a;};
  Mint operator-(Mint a) const{return Mint(v)-=a;};
  Mint operator*(Mint a) const{return Mint(v)*=a;};
  Mint operator/(Mint a) const{return Mint(v)/=a;};

  Mint operator-() const{return v?Mint(MOD-v):Mint(v);}

  bool operator==(const Mint a)const{return v==a.v;}
  bool operator!=(const Mint a)const{return v!=a.v;}
  bool operator <(const Mint a)const{return v <a.v;}

};
template<typename T,T MOD> constexpr T Mint<T, MOD>::mod;
template<typename T,T MOD>
ostream& operator<<(ostream &os,Mint<T, MOD> m){os<<m.v;return os;}

//INSERT ABOVE HERE

NTT<2> ntt;
using M = Mint<Int, ntt.md>;
vector<M> res;

void dfs(vector<Int> &as,vector<Int> &bs,Int l,Int r){
  if(r-l==1) return;
  Int m=(l+r)>>1;
  vector<Int> cs(m-l);
  vector<Int> ds(r-m);
  for(Int i=l;i<m;i++) cs[i-l]=as[i];
  for(Int i=m;i<r;i++) ds[i-m]=bs[i];
  auto es=ntt.multiply(cs,ds);
  for(Int i=0;i<(Int)es.size();i++)
    res[l+m+i]+=M(es[i]);
  dfs(as,bs,l,m);
  dfs(as,bs,m,r);
}

signed main(){
  string s;
  cin>>s;
  Int n=s.size();
  vector<Int> us(n),gs(n),qs(n);
  Int num=0;
  for(Int i=0;i<n;i++){
    us[i]=s[i]=='U';
    gs[i]=s[i]=='G';
    qs[i]=s[i]=='?';

    num+=qs[i];
  }

  M ans{0};
  // U (M / ?) G
  {
    res.assign(2*n,0);
    dfs(us,gs,0,n);
    for(Int i=0;i<n;i++){
      if(s[i]=='M'){
        ans+=res[i*2]*M(3).pow(num);
      }
      if(s[i]=='?'){
        ans+=res[i*2]*M(3).pow(num-1);
      }
    }
  }
  // ? (M / ?) G
  {
    res.assign(2*n,0);
    dfs(qs,gs,0,n);
    for(Int i=0;i<n;i++){
      if(s[i]=='M'){
        if(num>=1)
          ans+=res[i*2]*M(3).pow(num-1);
      }
      if(s[i]=='?'){
        if(num>=2)
          ans+=res[i*2]*M(3).pow(num-2);
      }
    }
  }

  // U (M / ?) ?
  {
    res.assign(2*n,0);
    dfs(us,qs,0,n);
    for(Int i=0;i<n;i++){
      if(s[i]=='M'){
        if(num>=1)
          ans+=res[i*2]*M(3).pow(num-1);
      }
      if(s[i]=='?'){
        if(num>=2)
          ans+=res[i*2]*M(3).pow(num-2);
      }
    }
  }

  // ? (M / ?) ?
  {
    res.assign(2*n,0);
    dfs(qs,qs,0,n);
    for(Int i=0;i<n;i++){
      if(s[i]=='M'){
        if(num>=2)
          ans+=res[i*2]*M(3).pow(num-2);
      }
      if(s[i]=='?'){
        if(num>=3)
          ans+=res[i*2]*M(3).pow(num-3);
      }
    }
  }

  cout<<ans<<endl;
  return 0;
}



Measured memory_bytes: 34880