#include <cstdio>
#include <vector>
#include <cassert>
#include <cstring>
#include <algorithm>

#define rep(i,n) for(int i=0;i<(n);i++)

using namespace std;

const char *SUIT="SHDC";

struct card{
    int num;
    char suit;
    void parse(const char *s){
        suit=s[0];
        if     (s[1]=='A') num=1;
        else if(s[1]=='T') num=10;
        else if(s[1]=='J') num=11;
        else if(s[1]=='Q') num=12;
        else if(s[1]=='K') num=13;
        else               num=s[1]-'0';
    }
    bool operator==(const card &C)const{ return num==C.num && suit==C.suit; }
    bool operator<(const card &C)const{ return (num==1?100:num)>(C.num==1?100:C.num); }
};

struct hand{
    int rank;
    card c[5];
    vector<int> seq;
    bool operator<(const hand &h)const{
        if(rank!=h.rank) return rank>h.rank;
        else{
            rep(i,5) if(seq[i]!=h.seq[i]) {
                return (seq[i]==1?100:seq[i])>(h.seq[i]==1?100:h.seq[i]);
            }
            return false;
        }
    }
};

void parse(int n,const char *s,card *res){
    int len=strlen(s);
    int m=0,pre=0;
    rep(i,len+1) if(i==len || s[i]==' ') {
        res[m++].parse(s+pre);
        pre=i+1;
    }
}

bool isflush(const card *C){
    return C[0].suit==C[1].suit
        && C[0].suit==C[2].suit
        && C[0].suit==C[3].suit
        && C[0].suit==C[4].suit;
}

bool isstraight(const card *C){
    if(C[0].num==1){
        if(C[1].num==13 && C[2].num==12 && C[3].num==11 && C[4].num==10) return true;
        if(C[1].num== 5 && C[2].num== 4 && C[3].num== 3 && C[4].num== 2) return true;
        return false;
    }
    else{
        return C[0].num==C[1].num+1 && C[1].num==C[2].num+1 && C[2].num==C[3].num+1 && C[3].num==C[4].num+1;
    }
}

int maxfreq(const card *C){
    int freq[14]={};
    rep(i,5){
        freq[C[i].num]++;
    }
    return *max_element(freq,freq+14);
}

hand calc_hand(card *C){
    sort(C,C+5);
    hand h;
    rep(i,5) h.seq.push_back(C[i].num);

    // royal straight flush
    if(isflush(C) && isstraight(C) && C[0].num==1 && C[1].num==13){
        h.rank=10;
    }
    // straight flush
    else if(isflush(C) && isstraight(C)){
        h.rank=9;
        if(C[0].num==1){
            h.seq[0]=5;
            h.seq[1]=4;
            h.seq[2]=3;
            h.seq[3]=2;
            h.seq[4]=1;
        }
    }
    // four a kind
    else if(maxfreq(C)==4){
        h.rank=8;
        if(C[0].num!=C[1].num){
            swap(h.seq[0],h.seq[4]);
        }
    }
    // full house
    else if(C[0].num==C[1].num && C[3].num==C[4].num && (C[2].num==C[0].num || C[2].num==C[3].num)){
        h.rank=7;
        if(C[2].num==C[3].num){
            swap(h.seq[0],h.seq[3]);
            swap(h.seq[1],h.seq[4]);
        }
    }
    // flush
    else if(isflush(C)){
        h.rank=6;
    }
    // straight
    else if(isstraight(C)){
        h.rank=5;
        if(C[0].num==1 && C[1].num!=13){
            h.seq[0]=5;
            h.seq[1]=4;
            h.seq[2]=3;
            h.seq[3]=2;
            h.seq[4]=1;
        }
    }
    // three of a kind
    else if(maxfreq(C)==3){
        h.rank=4;
        if     (C[0].num==C[1].num && C[0].num==C[2].num);
        else if(C[1].num==C[2].num && C[1].num==C[3].num) swap(h.seq[0],h.seq[3]);
        else if(C[2].num==C[3].num && C[2].num==C[4].num) swap(h.seq[0],h.seq[3]), swap(h.seq[1],h.seq[4]);
        else assert(0);
    }
    // two pairs
    else if(C[0].num==C[1].num && C[2].num==C[3].num
         || C[0].num==C[1].num && C[3].num==C[4].num
         || C[1].num==C[2].num && C[3].num==C[4].num){
        h.rank=3;
        if(C[0].num==C[1].num && C[2].num==C[3].num);
        else if(C[0].num==C[1].num && C[3].num==C[4].num){
            swap(h.seq[2],h.seq[4]);
        }
        else{
            swap(h.seq[0],h.seq[2]);
            swap(h.seq[2],h.seq[4]);
        }
    }
    // one pair
    else if(maxfreq(C)==2){
        h.rank=2;
        if     (C[0].num==C[1].num);
        else if(C[1].num==C[2].num) swap(h.seq[0],h.seq[2]);
        else if(C[2].num==C[3].num) swap(h.seq[0],h.seq[2]), swap(h.seq[1],h.seq[3]);
        else if(C[3].num==C[4].num) swap(h.seq[0],h.seq[3]), swap(h.seq[1],h.seq[4]), swap(h.seq[2],h.seq[3]), swap(h.seq[3],h.seq[4]);
        else assert(0);
    }
    // high card
    else{
        h.rank=1;
    }

    return h;
}

hand get_best_hand(const card *C,const card *flop,card turn,card river){
    hand res; res.rank=-1;

    card c[7]={C[0],C[1],flop[0],flop[1],flop[2],turn,river};

    for(int S=(1<<5)-1,x,y;S&&S<(1<<7);x=S&-S,y=S+x,S=((S&~y)/x>>1)|y){
        int m=0;
        card chosen[5];
        rep(k,7) if(S>>k&1) chosen[m++]=c[k];
        res=min(res,calc_hand(chosen));

        if(S==0) break;
    }

    return res;
}

int main(){
    while(1){
        char s1[10],s2[10],s3[10];
        fgets(s1,10,stdin);
        fgets(s2,10,stdin);
        fgets(s3,10,stdin);
        if(s1[0]=='#') break;

        card C1[2],C2[2],flop[3];
        parse(2,s1,C1);
        parse(2,s2,C2);
        parse(3,s3,flop);

        vector<card> yama;
        for(int i=1;i<=13;i++) rep(j,4) {
            card c={i,SUIT[j]};

            bool ok=true;
            if(C1[0]==c || C1[1]==c) ok=false;
            if(C2[0]==c || C2[1]==c) ok=false;
            if(flop[0]==c || flop[1]==c || flop[2]==c) ok=false;

            if(ok) yama.push_back(c);
        }

        int win=0;
        rep(i,yama.size()) rep(j,i) {
            hand h1=get_best_hand(C1,flop,yama[i],yama[j]);
            hand h2=get_best_hand(C2,flop,yama[i],yama[j]);
            if(h1<h2) win++;
        }
        printf("%.15f\n",(double)win/(yama.size()*(yama.size()-1)/2));
    }

    return 0;
}

/*
SA DA
SQ DQ
S5 S4 S3
*/

Measured memory_bytes: 1068