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

#define REP(i,a,b) for(i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)

#define mygc(c) (c)=getchar_unlocked()
#define mypc(c) putchar_unlocked(c)

#define ll long long
#define ull unsigned ll

void reader(int *x){int k,m=0;*x=0;for(;;){mygc(k);if(k=='-'){m=1;break;}if('0'<=k&&k<='9'){*x=k-'0';break;}}for(;;){mygc(k);if(k<'0'||k>'9')break;*x=(*x)*10+k-'0';}if(m)(*x)=-(*x);}
void reader(ll *x){int k,m=0;*x=0;for(;;){mygc(k);if(k=='-'){m=1;break;}if('0'<=k&&k<='9'){*x=k-'0';break;}}for(;;){mygc(k);if(k<'0'||k>'9')break;*x=(*x)*10+k-'0';}if(m)(*x)=-(*x);}
void reader(double *x){scanf("%lf",x);}
int reader(char c[]){int i,s=0;for(;;){mygc(i);if(i!=' '&&i!='\n'&&i!='\r'&&i!='\t'&&i!=EOF) break;}c[s++]=i;for(;;){mygc(i);if(i==' '||i=='\n'||i=='\r'||i=='\t'||i==EOF) break;c[s++]=i;}c[s]='\0';return s;}
template <class T, class S> void reader(T *x, S *y){reader(x);reader(y);}
template <class T, class S, class U> void reader(T *x, S *y, U *z){reader(x);reader(y);reader(z);}
template <class T, class S, class U, class V> void reader(T *x, S *y, U *z, V *w){reader(x);reader(y);reader(z);reader(w);}

void writer(int x, char c){int s=0,m=0;char f[10];if(x<0)m=1,x=-x;while(x)f[s++]=x%10,x/=10;if(!s)f[s++]=0;if(m)mypc('-');while(s--)mypc(f[s]+'0');mypc(c);}
void writer(ll x, char c){int s=0,m=0;char f[20];if(x<0)m=1,x=-x;while(x)f[s++]=x%10,x/=10;if(!s)f[s++]=0;if(m)mypc('-');while(s--)mypc(f[s]+'0');mypc(c);}
void writer(double x, char c){printf("%.15f",x);mypc(c);}
void writer(const char c[]){int i;for(i=0;c[i]!='\0';i++)mypc(c[i]);}
void writer(const char x[], char c){int i;for(i=0;x[i]!='\0';i++)mypc(x[i]);mypc(c);}
template<class T> void writerLn(T x){writer(x,'\n');}
template<class T, class S> void writerLn(T x, S y){writer(x,' ');writer(y,'\n');}
template<class T, class S, class U> void writerLn(T x, S y, U z){writer(x,' ');writer(y,' ');writer(z,'\n');}
template<class T> void writerArr(T x[], int n){int i;if(!n){mypc('\n');return;}rep(i,n-1)writer(x[i],' ');writer(x[n-1],'\n');}

char memarr[17000000]; void *mem = memarr;
#define MD 1000000007
#define INF 5000000000000000000LL

template <class T>
struct heapEx {
  int *hp, *place, size; T *val;

  void malloc(int N){hp=(int*)std::malloc(N*sizeof(int));place=(int*)std::malloc(N*sizeof(int));val=(T*)std::malloc(N*sizeof(T));}
  void free(){free(hp);free(place);free(val);}
  void* malloc(int N, void *workMemory){hp=(int*)workMemory;workMemory=(void*)(hp+N);place=(int*)workMemory;workMemory=(void*)(place+N);val=(T*)workMemory;workMemory=(void*)(val+N);return workMemory;}
  void init(int N){int i;size=0;rep(i,N)place[i]=-1;}
  void up(int n){int m;while(n){m=(n-1)/2;if(val[hp[m]]<=val[hp[n]])break;swap(hp[m],hp[n]);swap(place[hp[m]],place[hp[n]]);n=m;}}
  void down(int n){int m;for(;;){m=2*n+1;if(m>=size)break;if(m+1<size&&val[hp[m]]>val[hp[m+1]])m++;if(val[hp[m]]>=val[hp[n]])break;swap(hp[m],hp[n]);swap(place[hp[m]],place[hp[n]]);n=m;}}
  void change(int n, T v){T f=val[n];val[n]=v;if(place[n]==-1){place[n] = size;hp[size++] = n;up(place[n]);}else{if(f < v) down(place[n]); else if(f > v) up(place[n]);}}
  int pop(void){int res=hp[0];place[res]=-1;size--;if(size)hp[0]=hp[size],place[hp[0]]=0,down(0);return res;}
};

template<class T> T GCD(T a,T b){T r; while(a)r=b,b=a,a=r%a; return b;}
template<class T> T LCM(T a,T b){return a/GCD(a,b)*b;}
template<class T> T GCD(T a,T b,T c){return GCD(GCD(a,b),c);}
template<class T> T LCM(T a,T b,T c){return LCM(LCM(a,b),c);}
template<class T> void reduceFraction(T&a, T&b){T g=GCD(a,b);a/=g;b/=g;}


ll comb(ll a, ll b){
  ll i, res = 1;
  ll x, y, g;

  b = min(b, a-b);

  rep(i,b){
    if((double)res * (a-i) / (i+1) > INF) return INF;
    g = GCD(a-i, i+1);
    x = (a-i) / g;
    y = (i+1) / g;
    res /= y;
    res *= x;
  }

  return res;
}

double dcomb(ll a, ll b){
  ll i;
  double res = 1;

  b = min(b, a-b);

  rep(i,b){
    res /= (i+1);
    res *= (a-i);
  }

  return res;
}

ll mul(ll a, ll b){
  if((double) a * b > INF) return INF;
  return a * b;
}

ll cnt[26], cnt2[26];
int N;
char S[1000100];
int arr[1000000];

heapEx<double> heap;

ll now[1000000];

ll solve(ll tot, int arr[], int sz){
  int i, j, k;
  ll A, B, C1, C2, D1, D2;
  ll res, rest;

  if(sz==0){
    return 1;
  }
  if(sz==1){
    return comb(tot, arr[0]);
  }
  if(sz==2){
    A = arr[0];
    B = tot - arr[1];
    res = 0;
    while(A < B-10){
      C1 = (A+A+B) / 3;
      C2 = (A+B+B) / 3;
      D1 = mul(comb(C1,arr[0]), comb(tot-C1,arr[1]));
      D2 = mul(comb(C2,arr[0]), comb(tot-C2,arr[1]));
      res = max(res, max(D1,D2));
      if(D1 < D2) A = C1; else B = C2;
    }
    while(A <= B){
      D1 = mul(comb(A,arr[0]), comb(tot-A,arr[1]));
      res = max(res, D1);
      A++;
    }
    return res;
  }

  heap.init(sz);
  res = 1;
  rest = tot;
  rep(i,sz) rest -= arr[i], now[i] = arr[i];
  rep(i,sz) heap.change(i, dcomb(now[i],arr[i]) / dcomb(now[i]+1,arr[i]));
  while(rest){
    i = heap.hp[0];
    res /= comb(now[i], arr[i]);
    res = mul(res,comb(now[i]+1, arr[i]));
    if(res >= INF) return res;
    now[i]++;
    heap.change(i, dcomb(now[i],arr[i]) / dcomb(now[i]+1,arr[i]));
    rest--;
  }

  rep(i,sz) res = mul(res, comb(now[i],arr[i]));
  return res;
}

int main(){
  int i, j, k, sz;
  ll res = 1, tmp;

  heap.malloc(1000001);

  rep(i,26) reader(cnt+i);
  N = reader(S);

  rep(i,N){
    S[i] -= 'a';
    cnt2[S[i]]++;
  }

  rep(i,26) if(cnt[i] < cnt2[i]){
    writerLn(0);
    return 0;
  }

  rep(k,26){
    sz = 0;
    rep(i,N) if(S[i]==k){
      arr[sz] = 1;
      while(i+1<N && S[i+1]==k) arr[sz]++, i++;
      sz++;
    }
    tmp = solve(cnt[k], arr, sz);
//    printf("%d (%c) : %lld\n",k,'a'+k,tmp);
//    writerArr(arr,sz);
    if((double)res * tmp > INF || res * tmp >= (1ULL<<62)){
      writerLn("hel");
      return 0;
    }
    res *= tmp;
  }

  writerLn(res);

  return 0;
}