#include<bits/stdc++.h>
typedef uint64_t u64;
typedef int64_t i64;
using namespace std;

void solve();

int main(){
  cout<<fixed<<setprecision(0);
  bool is_multicase=false;
  int T=1;
  if(is_multicase){
    cin>>T;
  }
  for(int i=0;i<T;++i){
    solve();
  }
  return 0;
}

template<typename T> void turtle_in(T& n){
  cin>>n;
}

template<typename T,typename U> void turtle_in(pair<T,U>& p){
  turtle_in(p.first);
  turtle_in(p.second);
}

template<typename T> void turtle_in(vector<T>& v){
  for(auto& u:v){
    turtle_in(u);
  }
}

template<typename T> void turtle_out(T& n){
  cout<<n;
}

template<typename T,typename U> void turtle_out(pair<T,U>& p){
  cout<<"{";
  turtle_out(p.first);
  cout<<", ";
  turtle_out(p.second);
  cout<<"}";
}

template<typename T> void turtle_out(vector<T>& v){
  for(int i=0;i<int(v.size());++i){
    turtle_out(v[i]);
    if(i!=v.size()-1){
      cout<<" ";
    }
  }
  cout<<endl;
}

template<typename T> void turtle_out(vector<vector<T>>& v){
  for(int i=0;i<int(v.size());++i){
    turtle_out(v[i]);
  }
}

void scan(){}

template<typename T,class... Args> void scan(T& n,Args&... args){
  turtle_in(n);
  scan(args...);
}

void print(){}

template<typename T,class... Args> void print(T n,Args... args){
  turtle_out(n);
  print(args...);
}

template<typename T> void println(T n){
  turtle_out(n);
  cout<<endl;
}

template<typename T,class... Args> void println(T n,Args... args){
  turtle_out(n);
  cout<<" ";
  println(args...);
}

template<u64 mod> struct modint{
  u64 val;
  modint(i64 val_=0):val((val_%i64(mod)+i64(mod))%i64(mod)){}
  modint operator-(){
    return modint(mod-val);
  }
  modint operator+(modint rhs){
    return modint(*this)+=rhs;
  }
  modint operator-(modint rhs){
    return modint(*this)-=rhs;
  }
  modint operator*(modint rhs){
    return modint(*this)*=rhs;
  }
  modint operator/(modint rhs){
    return modint(*this)/=rhs;
  }
  modint &operator+=(modint rhs){
    val+=rhs.val;
    val-=((val>=mod)?mod:0);
    return (*this);
  }
  modint &operator-=(modint rhs){
    val+=((val<rhs.val)?mod:0);
    val-=rhs.val;
    return (*this);
  }
  modint &operator*=(modint rhs){
    val=val*rhs.val%mod;
    return (*this);
  }
  modint &operator/=(modint rhs){
    u64 ex=mod-2;
    modint now=1;
    while(ex){
      now*=((ex&1)?rhs:1);
      rhs*=rhs,ex>>=1;
    }
    return (*this)*=now;
  }
  bool operator==(modint rhs){
    return val==rhs.val;
  }
  bool operator!=(modint rhs){
    return val!=rhs.val;
  }
  friend std::ostream &operator<<(std::ostream& os,modint x){
    return os<<(x.val);
  }
  friend std::istream &operator>>(std::istream& is,modint& x){
    u64 t;
    is>>t,x=t;
    return is;
  }
};

template<typename T,typename U> T power(T a,U n){
  T res=1;
  while(n>0){
    if(n%2==1){
      res*=a;
    }
    a*=a;
    n/=2;
  }
  return res;
}

template<typename T> struct genrand{
  uniform_int_distribution<T> gen;
  mt19937 engine;
  genrand(T a,T b):gen(a,b){
    random_device seed_gen;
    engine.seed(seed_gen());
  }
  T operator()(){
    return gen(engine);
  }
};

template<typename T> struct comb{
  vector<T> dat,idat;
  comb(int mx=3000000):dat(mx+1,1),idat(mx+1,1){
    for(int i=1;i<=mx;++i){
      dat[i]=dat[i-1]*i;
    }
    idat[mx]/=dat[mx];
    for(int i=mx;i>0;--i){
      idat[i-1]=idat[i]*i;
    }
  }
  T operator()(int n,int k){
    if(n<0||k<0||n<k){
      return 0;
    }
    return dat[n]*idat[k]*idat[n-k];
  }
};

template<u64 mod> struct NTT{
  typedef modint<mod> mint;
  mint g=0;
  int limit=0;
  vector<mint> zeta;
  
  mint power_NTT(mint a,u64 n){
    mint res=1;
    while(n){
      res*=((n&1)?a:1);
      a*=a;
      n>>=1;
    }
    return res;
  }
  
  NTT(){
    for(g=2;;g+=1){
      if(power_NTT(g,(mod-1)>>1)!=1){
        break;
      }
    }
    u64 now=(mod-1);
    while(!(now&1)){
      now>>=1;
      ++limit;
    }
    zeta.resize(limit+1,1);
    zeta[limit]=power_NTT(g,now);
    for(int i=limit-1;i>=0;--i){
      zeta[i]=zeta[i+1]*zeta[i+1];
    }
  }
  
  void dft(vector<mint>& f,int cnt){
    for(int i=0;i<(1<<cnt);++i){
      int j=0;
      for(int k=0;k<cnt;++k){
        j+=((i>>k)&1)<<(cnt-1-k);
      }
      if(i<j){
        swap(f[i],f[j]);
      }
    }
    for(int b=0;b<cnt;++b){
      mint now=1;
      for(int j=0;j<(1<<b);++j){
        for(int k=0;k<(1<<cnt);k+=(1<<(b+1))){
          mint s=f[k+j],t=f[k+j+(1<<b)]*now;
          f[k+j]=s+t,f[k+j+(1<<b)]=s-t;
        }
        now*=zeta[b+1];
      }
    }
  }
  
  vector<mint> mul_naive(vector<mint> a,vector<mint> b){
    vector<mint> res(a.size()+b.size()-1);
    for(int i=0;i<int(a.size());++i){
      for(int j=0;j<int(b.size());++j){
        res[i+j]+=a[i]*b[j];
      }
    }
    return res;
  }
  
  vector<mint> mul_fast(vector<mint> a,vector<mint> b){
    int cnt=0,siz=1,mxsiz=a.size()+b.size()-1;
    while(siz<mxsiz){
      siz<<=1,++cnt;
    }
    assert(cnt<=limit);
    a.resize(siz),b.resize(siz);
    dft(a,cnt),dft(b,cnt);
    for(int i=0;i<siz;++i){
      a[i]*=b[i];
    }
    dft(a,cnt);
    reverse(a.begin()+1,a.end());
    mint isiz=mint(1)/siz;
    for(int i=0;i<siz;++i){
      a[i]*=isiz;
    }
    a.resize(mxsiz);
    return a;
  }
  
  vector<mint> mul(vector<mint> a,vector<mint> b){
    if(min(a.size(),b.size())<=64){
      return mul_naive(a,b);
    }
    else{
      return mul_fast(a,b);
    }
  }
};

template<u64 mod> struct Poly{
  typedef modint<mod> mint;
  NTT<mod> ntt;
  vector<mint> val;
  
  Poly():val({0}){}
  Poly(mint t):val({t}){}
  Poly(int siz):val(max(1,siz)){}
  Poly(initializer_list<modint<mod>> init):val(init){}
  Poly(vector<mint> init):val(init){}
  
  mint &operator[](int i){
    return val[i];
  }
  
  int size(){
    return val.size();
  }
  
  void resize(int siz){
    val.resize(siz);
  }
  
  Poly operator+(Poly rhs){
    return Poly(*this)+=rhs;
  }
  
  Poly operator-(Poly rhs){
    return Poly(*this)-=rhs;
  }
  
  Poly operator*(Poly rhs){
    return Poly(*this)*=rhs;
  }
  
  Poly operator/(Poly rhs){
    return Poly(*this)/=rhs;
  }
  
  Poly operator%(Poly rhs){
    return Poly(*this)%=rhs;
  }
  
  Poly operator-(){
    for(mint& v:val){
      v=mint(0)-v;
    }
    return (*this);
  }
  
  Poly operator+=(Poly rhs){
    resize(max(this->size(),rhs.size()));
    for(int i=0;i<int(rhs.size());++i){
      (*this)[i]+=rhs[i];
    }
    shrink();
    return (*this);
  }
  
  Poly operator-=(Poly rhs){
    resize(max(this->size(),rhs.size()));
    for(int i=0;i<int(rhs.size());++i){
      (*this)[i]-=rhs[i];
    }
    shrink();
    return (*this);
  }
  
  Poly operator*=(Poly rhs){
    val=ntt.mul(val,rhs.val);
    return (*this);
  }
  
  Poly operator/=(Poly rhs){
    if(val.size()<rhs.size()){
      val.resize(0);
      return (*this);
    }
    int rsiz=val.size()-rhs.size()+1;
    reverse(val.begin(),val.end());
    reverse(rhs.val.begin(),rhs.val.end());
    val.resize(rsiz),rhs.inv(rsiz);
    (*this)*=rhs;
    val.resize(rsiz);
    reverse(val.begin(),val.end());
    return (*this);
  }
  
  Poly operator%=(Poly rhs){
    if(val.size()<rhs.size()){
      return (*this);
    }
    (*this)-=(*this)/rhs*rhs;
    val.resize(rhs.size()-1);
    shrink();
    return (*this);
  }
  
  void inv(int mx){
    Poly g({mint(1)/val[0]});
    int now=1;
    while(now<mx){
      now<<=1;
      Poly t=(*this);
      t.resize(now);
      t*=g,t=-t;
      t[0]+=2,g*=t;
      g.resize(now);
    }
    g.resize(mx);
    (*this)=g;
  }
  
  void shrink(){
    for(int i=val.size()-1;i>0;--i){
      if(val[i]==0){
        val.pop_back();
      }
      else{
        return;
      }
    }
  }
  
  vector<mint> multieval(vector<modint<mod>> a){
    int siz=1;
    while(siz<int(a.size())){
      siz<<=1;
    }
    vector<Poly<mod>> t(siz*2-1,{1});
    for(int i=0;i<int(a.size());++i){
      t[i+siz-1]={-a[i],1};
    }
    for(int i=siz-2;i>=0;--i){
      t[i]=t[2*i+1]*t[2*i+2];
    }
    vector<Poly<mod>> g(siz*2-1);
    g[0]=(*this)%t[0];
    for(int i=1;i<siz*2-1;++i){
      g[i]=g[(i-1)/2]%t[i];
    }
    vector<modint<mod>> res(a.size());
    for(int i=0;i<int(a.size());++i){
      res[i]=g[i+siz-1][0];
    }
    return res;
  }
  
  void product(vector<Poly<mod>> a){
    int siz=1;
    while(siz<int(a.size())){
      siz<<=1;
    }
    vector<Poly<mod>> res(siz*2-1,{1});
    for(int i=0;i<int(a.size());++i){
      res[i+siz-1]=a[i];
    }
    for(int i=siz-2;i>=0;--i){
      res[i]=res[2*i+1]*res[2*i+2];
    }
    (*this)=res[0];
  }
  
  void lagrange_interpolation(vector<mint> x,vector<mint> y){
    int N=x.size();
    vector<Poly<mod>> h(N);
    for(int i=0;i<N;++i){
      h[i]={-x[i],1};
    }
    Poly<mod> g;
    g.product(h);
    Poly<mod> g_=g;
    g_.diffrent();
    vector<mint> t=g_.multieval(x);
    for(int i=0;i<N;++i){
      t[i]=y[i]/t[i];
    }
    vector<Poly<mod>> den(2*N-1),num(2*N-1,{1});
    for(int i=0;i<N;++i){
      den[i+N-1]={-x[i],1};
      num[i+N-1]={t[i]};
    }
    for(int i=N-2;i>=0;--i){
      den[i]=den[2*i+1]*den[2*i+2];
      num[i]=num[2*i+1]*den[2*i+2]+num[2*i+2]*den[2*i+1];
    }
    (*this)=num[0];
  }
  
  void diffrent(){
    Poly f(val.size()-1);
    for(int i=1;i<val.size();++i){
      f[i-1]=val[i]*i;
    }
    (*this)=f;
  }
  
  void integral(){
    Poly f(val.size()+1);
    for(int i=0;i<val.size();++i){
      f[i+1]=val[i]/(i+1);
    }
    (*this)=f;
  }
  
  mint eval(mint a){
    mint t=1,res=0;
    int n=(*this).size();
    for(int i=0;i<n;++i){
      res+=val[i]*t;
      t*=a;
    }
    return res;
  }
  
  Poly power(i64 K){
    Poly res={1},c=(*this);
    while(K){
      if(K&1){
        res*=c;
      }
      c*=c;
      K/=2;
    }
    return res;
  }
};

void solve(){
  string S;
  scan(S);
  map<string,string> mp;
  mp["A"]="A#",mp["C"]="C#",mp["E"]="E#",mp["F"]="F#",mp["G"]="G#";
  mp["E"]="F",mp["B"]="C";
  println(mp[S]);
}