#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=double;
using pll=pair<ll,ll>;
using vll=vector<ll>;
using vpll=vector<pll>;
using vvll=vector<vll>;
#define FOR(i,a,b) for(ll i=a;i<(ll)b;++i)
#define ROF(i,a,b) for(ll i=a;i>=(ll)b;--i)
#define F(n) FOR(i,0,n)
#define FF(n) FOR(j,0,n)
#define aa first
#define bb second
#define PB push_back

struct Card{
  ll rank;
  ll suit;
};

Card hand[5];
ll rcount[15],scount[4],mods,lastRule,value;

vll ranks;
ll rankmap(char c){
  if(isdigit(c)){
    return c-'0';
  }
  if(c=='J')return 11;
  if(c=='Q')return 12;
  if(c=='K')return 13;
  if(c=='A')return 14;
  assert(0);
}

vector<char> suits={'D','H','C','S'};
ll suitmap(char c){
  switch(c){
    case 'D':
      return 0;
    case 'H':
      return 1;
    case 'C':
      return 2;
    case 'S':
      return 3;
    default:
      assert(0);
  }
}

ll valuemap(ll rank){
  return min(10ll,rank);
}

void printrule(ll n){
  //cout<<"Rule "<<n<<": "<<value<<endl;
}

void rule1(){
  value+=1;
  value+=rcount[rankmap('J')]*valuemap(hand[0].rank);
  ++mods;
  lastRule=1;
  printrule(1);
}

void rule2(){
  for(auto c:suits){
    if(scount[suitmap(c)]>=2){
      value*=2;
      ++mods;
      lastRule=2;
      break;
    }
  }
  printrule(2);
}

void rule3(){
  ll ss=0;
  for(auto c:suits){
    if(scount[suitmap(c)]>0){
      ++ss;
    }
  }
  if(ss>=4){
    value*=2;
    ++mods;
    lastRule=3;
  }
  printrule(3);
}

void rule4(){
  ll blacks=scount[suitmap('C')]+scount[suitmap('S')];
  ll reds=scount[suitmap('H')]+scount[suitmap('D')];
  if(blacks!=reds){
    value+=abs(blacks-reds);
    ++mods;
    lastRule=4;
  }
  printrule(4);
}

vll divisors(ll n){
  vll a,b;
  for(ll i=1;i<=(n+i-1)/i;++i){
    if(n%i==0)a.PB(i),b.PB(n/i);
  }
  if(b.back()==a.back())b.pop_back();
  reverse(b.begin(),b.end());
  a.insert(a.end(),b.begin(),b.end());
  assert(find(a.begin(),a.end(),1)!=a.end());
  assert(find(a.begin(),a.end(),n)!=a.end());
  return a;
}

void rule5(){
  if(value%2==0){
    vll divs=divisors(value);
    for(auto d:divs)value+=d;
    ++mods;
    lastRule=5;
  }
  printrule(5);
}

void rule6(){
  if(rcount[rankmap('7')]==4){
    value-=11*11;
    ++mods;
    lastRule=6;
  }
  printrule(6);
}

void rule7(){
  if(value>=0){
    ll r=20;
    F(5)r=min(r,valuemap(hand[i].rank));
    value+=r;
    ++mods;
    lastRule=7;
  }
  printrule(7);
}

void rule8(){
  if(value<0){
    value*=-1;
    ++mods;
    lastRule=8;
  }
  printrule(8);
}

void swapRanks(Card& c,char from,char to){
  ll rfrom=rankmap((from));
  ll rto=rankmap((to));
  assert(c.rank==rfrom);
  c.rank=rto;
  --rcount[rfrom];
  ++rcount[rto];
}

void rule9(){
  if(scount[suitmap('D')]>=3){
    value+=1;
    F(5){
      Card& cur=hand[i];
      if(cur.rank==rankmap('6')){
        swapRanks(cur,'6','9');
      }
      else if(cur.rank==rankmap('9')){
        swapRanks(cur,'9','6');
      }
      else if(cur.rank==rankmap('2')){
        swapRanks(cur,'2','5');
      }
      else if(cur.rank==rankmap('5')){
        swapRanks(cur,'5','2');
      }
    }
    ++mods;
    lastRule=9;
  }
  printrule(9);
}

void rule10(){
  bool gok=0;
  FOR(i,2,11){
    bool ok=1;
    FOR(j,0,5){
      if(rcount[i+j]<1){
        ok=0;
      }
    }
    gok|=ok;
  }
  if(gok){
    if(rcount[rankmap('A')]){
      value*=5*rcount[rankmap('A')];
      ++mods;
    }
    lastRule=10;
  }
  printrule(10);
}

void rule11(){
  if(mods>8){
    ll bits=__builtin_popcountll(value);
    if(bits){
      value+=bits;
      ++mods;
    }
    lastRule=11;
  }
  printrule(11);
}

void rule12(){
  if(rcount[rankmap('2')]>=1){
    switch(lastRule){
      case 1:
        rule1();
        break;
      case 2:
        rule2();
        break;
      case 3:
        rule3();
        break;
      case 4:
        rule4();
        break;
      case 5:
        rule5();
        break;
      case 6:
        rule6();
        break;
      case 7:
        rule7();
        break;
      case 8:
        rule8();
        break;
      case 9:
        rule9();
        break;
      case 10:
        rule10();
        break;
      case 11:
        rule11();
        break;
      default:
        //cout<<"Last rule: "<< lastRule<<endl;
        assert(0);
    }
    lastRule=12;
  }
  printrule(12);
}

vpll factors(ll n){
  vpll res;
  FOR(d,2,n&&n>1){
    ll p=0;
    while(n%d==0){
      ++p;
      n/=d;
    }
    if(p){
      res.PB({d,p});
    }
  }
  //cout<<"SF "<<n<<endl; for(auto a:res){ cout<<a.aa<<','<<a.bb<<endl; }
  return res;
}

ll pow(ll a,ll n){
  ll res=1;
  while(n>1)res*=a,--n;
  return res;
}

void rule13(){
  if(rcount[rankmap('2')]>=1){
    value*=2;
    ++mods;
    lastRule=13;
  }
  printrule(13);
}

int main(){
  ios::sync_with_stdio(0);
  FOR(r,2,14)ranks.PB(r);
  string __;
  F(5){
    Card& cur=hand[i];
    cin>>__;
    ll rank,suit;
    if(__[0]=='1'){
      rank=10;
      suit=suitmap(__[2]);
    }else{
      rank=rankmap(__[0]);
      suit=suitmap(__[1]);
    }
    cur.rank=rank;
    cur.suit=suit;
    ++rcount[rank];
    ++scount[suit];
  }
  F(5)value+=valuemap(hand[i].rank);
  //cout<<"Begin "<<value<<endl;
  rule1();
  rule2();
  rule3();
  rule4();
  rule5();
  rule6();
  rule7();
  rule8();
  rule9();
  rule10();
  rule11();
  rule12();
  rule13();
  cout<<value<<endl;
  
  return 0;
}