#!/bin/python3

import re
import sys
from pprint import pprint 
from collections import Counter

input_f  = sys.argv[1]

d =[]
rank = 0

strength = 'AKQJT98765432'
print(strength)

with open(input_f) as file:
    for line in file:
        d.append(line.split())
pprint(d)
print()

def same_kind(x):
    s = Counter(x)
    for i in s.values():
        if i == 4:
            return True
    return False

def five_of_kind(x):
    if len(Counter(x)) == 1:
            return True
    return False

def full_house(x):
    #print('full_house')
    s = Counter(x)
    if len(s) != 2:
        return False
    else:
        tmp = list(s.values())
        if (tmp[0] == 2 or tmp[0] == 3) and (tmp[1] == 2 or tmp[1] == 3):
            return True
        else:
            return False

def three_of_kind(x):
    s = Counter(x)
    for i in s.values():
        if i == 3:
            return True
    return False

def pairs(x):
    s = Counter(x)
    pairs = 0
    for i in s.values():
        if i == 2:
            pairs += 1
    return pairs


for idx,i in enumerate(d):
    d[idx].append(rank)
    
    # Five of a kind, where all five cards have the same label: AAAAA
    if five_of_kind(d[idx][0]) == True:
        d[idx][2] = 7
        continue

    #Four of a kind, where four cards have the same label and one card has a different label: AA8AA
    if same_kind(d[idx][0]) == True:
        d[idx][2] = 6
        continue

    #Full house, where three cards have the same label, and the remaining two cards share a different label: 23332
    if full_house(d[idx][0]) == True:
        d[idx][2] = 5
        continue

    #Three of a kind, where three cards have the same label, and the remaining two cards are each different from any other card in the hand: TTT98
    if three_of_kind(d[idx][0]) == True:
        d[idx][2] = 4
        continue

    #Two pair, where two cards share one label, two other cards share a second label, and the remaining card has a third label: 23432
    if pairs(d[idx][0]) == 2:
        d[idx][2] = 3
        continue

    #One pair, where two cards share one label, and the other three cards have a different label from the pair and each other: A23A4
    if pairs(d[idx][0]) == 1:
        d[idx][2] = 2
        continue

    #High card, where all cards' labels are distinct: 23456
    if pairs(d[idx][0]) == 0:
        d[idx][2] = 1
        continue

#d.sort()

#d = sorted(d, key=lambda x: x[2])

def pp(x):
    for p in x:
        for q in p:
            print(q,end='\t')
        print()

x_1 = []
x_2 = []
x_3 = []
x_4 = []
x_5 = []
x_6 = []
x_7 = []


for y in d:
    if y[2] == 1:
        x_1.append(y+[[strength.index(c) for c in y[0]]])
    if y[2] == 2:
        x_2.append(y+[[strength.index(c) for c in y[0]]])
    if y[2] == 3:
        x_3.append(y+[[strength.index(c) for c in y[0]]])
    if y[2] == 4:
        x_4.append(y+[[strength.index(c) for c in y[0]]])
    if y[2] == 5:
        x_5.append(y+[[strength.index(c) for c in y[0]]])
    if y[2] == 6:
        x_6.append(y+[[strength.index(c) for c in y[0]]])
    if y[2] == 7:
        x_7.append(y+[[strength.index(c) for c in y[0]]])


x_1 = sorted(x_1, key=lambda x: x[3],reverse=True)
x_2 = sorted(x_2, key=lambda x: x[3],reverse=True)
x_3 = sorted(x_3, key=lambda x: x[3],reverse=True)
x_4 = sorted(x_4, key=lambda x: x[3],reverse=True)
x_5 = sorted(x_5, key=lambda x: x[3],reverse=True)
x_6 = sorted(x_6, key=lambda x: x[3],reverse=True)
x_7 = sorted(x_7, key=lambda x: x[3],reverse=True)

#def sortkey_part1(hand):
#        return [score_hand(hand)] + ['23456789TJQKA'.index(c) for c in hand]


e = []

X = [x_1,x_2,x_3,x_4,x_5,x_6,x_7]

for n in X:
    for m in n:
        e.append(m)

pprint(e)

"""
pprint(d)
print()
for idx,i in enumerate(d):
    if idx == len(d)-1:
        break
    else:
        if d[idx][2] == d[idx+1][2]:
            #print('Comparing ' + str(d[idx][0]) + ' to ' + str(d[idx+1][0]))
            tmp = list(d[idx][0])
            tmp2 = list(d[idx+1][0])
            for x in range(0,5):
                if tmp[x] != tmp2[x]:
                    #print(tmp[x],tmp2[x])
                    if strength.find(tmp[x]) < strength.find(tmp2[x]):
                        d[idx],d[idx+1] = d[idx+1],d[idx]
                        break
"""
result = 0

for idx,i in enumerate(e):
    x = i[1]
    result += (int(x) * (idx+1))

print(result)