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

#define INF_LL (int64)1e18
#define INF (int64)1e9
#define REP(i, n) for(int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for(int64 i = (a); i < (b); i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint32_t;
using int64 = int64_t;
using uint64 = uint64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

template<typename A, typename B> inline void chmin(A &a, B b) { if (a > b) a = b; }
template<typename A, typename B> inline void chmax(A &a, B b) { if (a < b) a = b; }
#define double long double
#define EPS (1e-4)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define PI 3.141592653589793238
struct Point3D{
  double x,y,z;
  Point3D(){}
  Point3D(double x,double y,double z):x(x),y(y),z(z){}
  Point3D operator+(Point3D p) {return Point3D(x+p.x,y+p.y,z+p.z);}
  Point3D operator-(Point3D p) {return Point3D(x-p.x,y-p.y,z-p.z);}
  Point3D operator*(double k){return Point3D(x*k,y*k,z*k);}
  Point3D operator/(double k){return Point3D(x/k,y/k,z/k);}
  Point3D operator*(Point3D p){
    return Point3D(y*p.z-z*p.y,z*p.x-x*p.z,x*p.y-y*p.x);
  }
  double operator^(Point3D p){
    return x*p.x+y*p.y+z*p.z;
  }
  double norm(){return x*x+y*y+z*z;}
  double abs(){return sqrt(norm());}
  bool operator < (const Point3D &p) const{
    if(x!=p.x) return x<p.x;
    if(y!=p.y) return y<p.y;
    return z<p.z;
  }
  bool operator == (const Point3D &p) const{
    return fabs(x-p.x)<EPS && fabs(y-p.y)<EPS && fabs(z-p.z)<EPS;
  }
};
istream &operator >> (istream &is,Point3D &p){
  is>>p.x>>p.y>>p.z;
  return is;
}
ostream &operator << (ostream &os,Point3D p){
  os<<fixed<<setprecision(12)<<p.x<<" "<<p.y<<" "<<p.z;
  return os;
}

typedef Point3D Vector3D;
typedef vector<Point3D> Polygon3D;

struct Segment3D{
  Point3D p1,p2;
  Segment3D(){}
  Segment3D(Point3D p1, Point3D p2):p1(p1),p2(p2){}
};
typedef Segment3D Line3D;

istream &operator >> (istream &is,Segment3D &s){
  is>>s.p1>>s.p2;
  return is;
}

struct Sphere{
  Point3D c;
  double r;
  Sphere(){}
  Sphere(Point3D c,double r):c(c),r(r){}
};

istream &operator >> (istream &is,Sphere &c){
  is>>c.c>>c.r;
  return is;
}

double norm(Vector3D a){
  return a.x*a.x+a.y*a.y+a.z*a.z;
}
double abs(Vector3D a){
  return sqrt(norm(a));
}
double dot(Vector3D a,Vector3D b){
  return a.x*b.x+a.y*b.y+a.z*b.z;
}
Vector3D cross(Vector3D a,Vector3D b){
  return Vector3D(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
}

Point3D project(Line3D l,Point3D p){
  Point3D b=l.p2-l.p1;
  double t=dot(p-l.p1,b)/norm(b);
  return l.p1+b*t;
}

Point3D reflect(Line3D l,Point3D p){
  return p+(project(l,p)-p)*2.0;
}

double getDistanceLP(Line3D l,Point3D p){
  return abs(cross(l.p2-l.p1,p-l.p1)/abs(l.p2-l.p1));
}

double getDistanceSP(Segment3D s,Point3D p){
  if(dot(s.p2-s.p1,p-s.p1) < 0.0 ) return abs(p-s.p1);
  if(dot(s.p1-s.p2,p-s.p2) < 0.0 ) return abs(p-s.p2);
  return getDistanceLP(s,p);
}

bool intersectSC(Segment3D s,Sphere c){
  double d=getDistanceSP(s,c.c);
  if(d>c.r) return 0;
  return !((abs(s.p1-c.c)<=c.r)&&(abs(s.p2-c.c)<=c.r));
}

struct ConvexHull3D{
  struct face{
    int a,b,c;
    bool ok;
    face(){}
    face(int a,int b,int c,bool ok):a(a),b(b),c(c),ok(ok){}
  };
  int n,num;
  vector<Point3D> p;
  vector<face> f;
  vector<vector<int> >  g;

  ConvexHull3D(int n):n(n),p(n),f(n*8),g(n,vector<int>(n)){}

  void input(){
    for(int i=0;i<n;i++) cin>>p[i];
  }

  double dblcmp(Point3D q,face f){
    Point3D m=p[f.b]-p[f.a];
    Point3D n=p[f.c]-p[f.a];
    Point3D t=q-p[f.a];
    return (m*n)^t;
  }

  void deal(int q,int a,int b){
    int idx=g[a][b];
    face add;
    if(f[idx].ok){
      if(dblcmp(p[q],f[idx])>EPS) dfs(q,idx);
      else{
        add=face(b,a,q,1);
        g[q][b]=g[a][q]=g[b][a]=num;
        f[num++]=add;
      }
    }
  }

  void dfs(int q,int now){
    f[now].ok=0;
    deal(q,f[now].b,f[now].a);
    deal(q,f[now].c,f[now].b);
    deal(q,f[now].a,f[now].c);
  }

  void build(){
    num=0;
    if(n<4) return;
    bool flg=1;
    for(int i=1;i<n;i++){
      if(abs(p[0]-p[i])>EPS){
        swap(p[1],p[i]);
        flg=0;
        break;
      }
    }
    if(flg) return;
    flg=1;
    for(int i=2;i<n;i++){
      if(abs((p[0]-p[1])*(p[1]-p[i]))>EPS){
        swap(p[2],p[i]);
        flg=0;
        break;
      }
    }
    if(flg) return;
    flg=1;
    for(int i=3;i<n;i++){
      if(abs(((p[0]-p[1])*(p[1]-p[2]))^(p[0]-p[i]))>EPS){
        swap(p[3],p[i]);
        flg=0;
        break;
      }
    }
    if(flg) return;
    face add;
    for(int i=0;i<4;i++){
      add=face((i+1)%4,(i+2)%4,(i+3)%4,1);
      if(dblcmp(p[i],add)>0) swap(add.b,add.c);
      g[add.a][add.b]=g[add.b][add.c]=g[add.c][add.a]=num;
      f[num++]=add;
    }
    for(int i=4;i<n;i++){
      for(int j=0;j<num;j++){
        if(f[j].ok&&dblcmp(p[i],f[j])>EPS){
          dfs(i,j);
          break;
        }
      }
    }
    int tmp=num;
    num=0;
    for(int i=0;i<tmp;i++)
      if(f[i].ok) f[num++]=f[i];
  }

  double volume(Point3D a,Point3D b,Point3D c,Point3D d){
    return ((b-a)*(c-a))^(d-a);
  }

  bool same(int s,int t){
    Point3D &a=p[f[s].a];
    Point3D &b=p[f[s].b];
    Point3D &c=p[f[s].c];
    return  (abs(volume(a,b,c,p[f[t].a]))<EPS)
            &&    (abs(volume(a,b,c,p[f[t].b]))<EPS)
            &&    (abs(volume(a,b,c,p[f[t].c]))<EPS);
  }

  int polygon(){
    int res=0;
    for(int i=0;i<num;i++){
      int flg=1;
      for(int j=0;j<i;j++)
        flg&=!same(i,j);
      res+=flg;
    }
    return res;
  }

  int triangle(){
    return num;
  }

  double area(Point3D a,Point3D b,Point3D c){
    return abs((b-a)*(c-a));
  }

  Point3D cross(Point3D a,Point3D b,Point3D c){
    return Point3D((b.y-a.y)*(c.z-a.z)-(b.z-a.z)*(c.y-a.y),
                   (b.z-a.z)*(c.x-a.x)-(b.x-a.x)*(c.z-a.z),
                   (b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x));
  }

  double area(){
    double res=0;
    if(n==3){
      Point3D q=cross(p[0],p[1],p[2]);
      res=abs(q)/2.0;
      return res;
    }
    return res;
    for(int i=0;i<num;i++)
      res+=area(p[f[i].a],p[f[i].b],p[f[i].c]);
    return res/2.0;
  }
};

int64 N(int64& d, const string &s="") {
  int64 ret = s[d]-'0';
  d++;
  while (d < s.size() && (s[d] == '0' || s[d] == '1')) {
    if (ret == 0) return -INF_LL;
    ret = (ret << 1) + s[d] -'0';
    d++;
  }
  return ret;
}

int64 E(int64&, const string&);

int64 F(int64& d, const string &s="") {
  if (s[d] == '-') {
    d++;
    int64 ret = F(d, s);
//    cout << "F_-_d " << ret << " " << d << endl;
    if (ret == -INF_LL) return ret;
    return -ret;
  } else if (s[d] == '(') {
    d++;
    int64 ret = E(d, s);
    if (s[d] != ')') return -INF_LL;
    d++;
    return ret;
  } else if (s[d] == '0' || s[d] == '1'){
    return N(d, s);
  } else {
    return -INF_LL;
  }
}

int64 T(int64& d, const string &s="") {
  int64 ret = F(d, s);
//  cout << "T_d " << ret << " " << d << endl;
  if (ret == -INF_LL) return -INF_LL;
  while (d < s.size() && s[d] == '*') {
    d++;
    int64 r = F(d, s);
    if (r == -INF_LL) return r;
    ret *= r;
  }
  return ret;
}

int64 E(int64& d, const string &s="") {
  int64 ret = T(d, s);
  if (ret == -INF_LL) return ret;
//  cout << "E_d " << ret << " " << d << endl;
  while (d < s.size() && (s[d] == '+' || s[d] == '-')) {
    if (s[d] == '+') {
      d++;
      int64 r = T(d, s);
      if (r == -INF_LL) return r;
      ret += r;
    } else if (s[d] == '-') {
      d++;
      int64 r = T(d, s);
      if (r == -INF_LL) return r;
      ret -= r;
    }
  }
  return ret;
}

bool ok(int64 d = 0, const string &s="") {
  int64 lhs = E(d, s);
//  cout << "ok" << lhs << endl;
  if (lhs == -INF_LL) return 0;
//  cout << "ok_d " << d << endl;
  if (s[d] != '=') return 0;
  d++;
  int64 rhs = E(d, s);
//  cout << "ok" << rhs << endl;
  if (rhs == -INF_LL || d != s.size()) return 0;
  return (lhs == rhs);
}

int main(void) {
  string s;
  string symbol = "=+-*()01";
  cin >> s;
  string chs = "";
  REP(i, s.size()) {
    if (symbol.find(s[i]) == string::npos && chs.find(s[i]) == string::npos) {
      chs += s[i];
    }
  }
  vector<int> idx(symbol.size(), -1);
  REP(i, chs.size()) {
    idx[symbol.size() - chs.size() + i] = i;
  }
  int64 res = 0;
  do {
    string t = "";
    char cvt[256] = {};
    REP(i, idx.size()) {
      if (idx[i] != -1) {
        cvt[chs[idx[i]]] = symbol[i];
      }
    }
    REP(i, s.size()) {
      if (symbol.find(s[i]) == string::npos) {
        t += cvt[s[i]];
      } else {
        t += s[i];
      }
    }
//    cout << t << " " << ok(0, t) << endl;
    if (ok(0, t)) {
//      cout << t << endl;
      res++;
    }
  } while (next_permutation(all(idx)));
  cout << res << endl;
}
