import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Rullete {
	public static void main(String[] args) {
		InputStream is = System.in;
		OutputStream os = System.out;
		InputReader in = new InputReader(is);
		PrintWriter out = new PrintWriter(os);

		String a = in.next();
		String b = in.next();
		String c = in.next();
		String d = in.next();
		String e = in.next();

		Rank[] ranks = { Rank.fromStr(a), Rank.fromStr(b), Rank.fromStr(c),
				Rank.fromStr(d), Rank.fromStr(e) };
		Suit[] suits = { Suit.fromStr(a), Suit.fromStr(b), Suit.fromStr(c),
				Suit.fromStr(d), Suit.fromStr(e) };

		int score = ranks[0].getScore() + ranks[1].getScore()
				+ ranks[2].getScore() + ranks[3].getScore()
				+ ranks[4].getScore();

		int modifiedrules = 0;
		int lastmodification = 0;

		// 1

		int result1 = rule1(score, ranks, suits);
		if (result1 != score) {
			modifiedrules++;
			lastmodification = 1;
			score = result1;
		}

		// 2

		int result2 = rule2(score, ranks, suits);
		if (result2 != score) {
			modifiedrules++;
			lastmodification = 2;
			score = result2;
		}

		// 3

		int result3 = rule3(score, ranks, suits);
		if (result3 != score) {
			modifiedrules++;
			lastmodification = 3;
			score = result3;
		}

		// 4

		int result4 = rule4(score, ranks, suits);
		if (result4 != score) {
			modifiedrules++;
			lastmodification = 4;
			score = result4;
		}

		// 5

		int result5 = rule5(score, ranks, suits);
		if (result5 != score) {
			modifiedrules++;
			lastmodification = 5;
			score = result5;
		}

		// 6

		int result6 = rule6(score, ranks, suits);
		if (result6 != score) {
			modifiedrules++;
			lastmodification = 6;
			score = result6;
		}

		// 7

		int result7 = rule7(score, ranks, suits);
		if (result7 != score) {
			modifiedrules++;
			lastmodification = 7;
			score = result7;
		}

		// 8

		int result8 = rule8(score, ranks, suits);
		if (result8 != score) {
			modifiedrules++;
			lastmodification = 8;
			score = result8;
		}

		// 9

		int result9 = rule9(score, ranks, suits);
		if (result9 != score) {
			modifiedrules++;
			lastmodification = 9;
			score = result9;
		}

		// 10

		Object[] result10 = rule10(score, ranks, suits);
		// if ((boolean)result10[1]) {
		if ((int) result10[0] != score) {
			modifiedrules++;
			lastmodification = 10;
			score = (int) result10[0];
		}

		// 11

		// int result11 = score;
		if (modifiedrules > 8) {
			int result11 = rule11(score, ranks, suits);
			if (result11 != score) {
				modifiedrules++;
				lastmodification = 11;
				score = result11;
			}
		}

		// 12

		for (Rank r : ranks) {
			if (r == Rank.r2) {

				switch (lastmodification) {
				case 1:
					score = rule1(score, ranks, suits);
					break;
				case 2:
					score = rule2(score, ranks, suits);
					break;
				case 3:
					score = rule3(score, ranks, suits);
					break;
				case 4:
					score = rule4(score, ranks, suits);
					break;
				case 5:
					score = rule5(score, ranks, suits);
					break;
				case 6:
					score = rule6(score, ranks, suits);
					break;
				case 7:
					score = rule7(score, ranks, suits);
					break;
				case 8:
					score = rule8(score, ranks, suits);
					break;
				case 9:
					score = rule9(score, ranks, suits);
					break;
				case 10:
					score = (int) rule10(score, ranks, suits)[0];
					break;
				case 11:
					score = rule11(score, ranks, suits);
					break;
				}
				break;
			}
		}

		// 13

		for (Rank r : ranks)
			if (r == Rank.r2) {

				int add = 1;
				for (int sp = 2; sp <= score; sp++)
					if (isPrime(sp)) {
						double pw = Math.log(score) / Math.log(sp);
						for (int p = (int) pw; p > 0; p--) {
							int superfactor = (int) Math.pow(sp, p);
							if (score % superfactor == 0) {
								add *= superfactor;
								break;
							}
						}
					}
				score += add;
				break;
			}

		out.print(score);
		out.close();
	}

	private static boolean isPrime(int sp) {
		for (int d = 2; d <= (int) Math.sqrt(sp); d++)
			if (sp % d == 0)
				return false;

		return true;
	}

	public static int rule1(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		if (ranks.length >= 4)
			newscore++;

		int Js = 0;
		for (Rank r : ranks)
			if (r == Rank.J)
				Js++;
		newscore += Js * ranks[0].getScore();

		return newscore;
	}

	public static int rule2(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		boolean ss = false;
		for (int s1 = 0; s1 < suits.length; s1++)
			for (int s2 = s1 + 1; s2 < suits.length; s2++)
				if (suits[s1] == suits[s2]) {
					ss = true;
					break;
				}

		if (ss) {
			newscore *= 2;
		}

		return newscore;
	}

	public static int rule3(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		boolean esD = false, esH = false, esC = false, esS = false;
		for (Suit s : suits) {
			if (s == Suit.D)
				esD = true;
			if (s == Suit.H)
				esH = true;
			if (s == Suit.C)
				esC = true;
			if (s == Suit.S)
				esS = true;
		}
		if (esD && esH && esC && esS) {
			newscore *= 2;
		}

		return newscore;
	}

	public static int rule4(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		int nB = 0, nR = 0;
		for (Suit s : suits) {
			if (s == Suit.D || s == Suit.H)
				nR++;
			if (s == Suit.C || s == Suit.S)
				nB++;
		}
		int dif = Math.abs(nR - nB);

		newscore += dif;

		return newscore;
	}

	public static int rule5(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		if ((score & 1) == 0) {
			int add = 0;
			for (int di = 1; di <= score; di++) {
				if (score % di == 0)
					add += di;
			}

			newscore += add;
		}

		return newscore;
	}

	public static int rule6(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		int rnk7 = 0;
		for (Rank r : ranks)
			if (r == Rank.r7)
				rnk7++;

		if (rnk7 == 4) {
			newscore -= 11 * 11;
		}

		return newscore;
	}

	public static int rule7(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		if (score >= 0) {
			int min = 100;
			for (Rank r : ranks)
				min = Math.min(r.getScore(), min);
			newscore += min;
		}

		return newscore;
	}

	public static int rule8(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		if (score < 0) {
			newscore *= -1;
		}

		return newscore;
	}

	public static int rule9(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		int stD = 0;
		for (Suit s : suits)
			if (s == Suit.D)
				stD++;
		if (stD >= 3) {
			newscore++;

			for (int i = 0; i < ranks.length; i++) {
				if (ranks[i] == Rank.r6) {
					ranks[i] = Rank.r9;
					continue;
				}
				if (ranks[i] == Rank.r9) {
					ranks[i] = Rank.r6;
					continue;
				}
				if (ranks[i] == Rank.r2) {
					ranks[i] = Rank.r5;
					continue;
				}
				if (ranks[i] == Rank.r5) {
					ranks[i] = Rank.r2;
					continue;
				}
			}
		}

		return newscore;
	}

	public static Object[] rule10(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;
		boolean mod = false;

		int strc = 0;
		boolean straight = false;
		boolean[] rnks = new boolean[13];
		for (Rank r : ranks)
			switch (r) {
			case r2:
				rnks[0] = true;
				break;
			case r3:
				rnks[1] = true;
				break;
			case r4:
				rnks[2] = true;
				break;
			case r5:
				rnks[3] = true;
				break;
			case r6:
				rnks[4] = true;
				break;
			case r7:
				rnks[5] = true;
				break;
			case r8:
				rnks[6] = true;
				break;
			case r9:
				rnks[7] = true;
				break;
			case r10:
				rnks[8] = true;
				break;
			case J:
				rnks[9] = true;
				break;
			case Q:
				rnks[10] = true;
				break;
			case K:
				rnks[11] = true;
				break;
			case A:
				rnks[12] = true;
				break;
			}

		for (int st = 0; st < 13; st++) {
			if (rnks[st])
				strc++;
			else
				strc = 0;
			if (strc == 5)
				straight = true;
		}
		if (straight) {
			int As = 0;
			for (Rank r : ranks)
				if (r == Rank.A)
					As++;
			newscore += As * 5;
			mod = true;
		}

		return new Object[] { newscore, mod };
	}

	public static int rule11(int score, Rank[] ranks, Suit[] suits) {
		int newscore = score;

		int b = 0;
		while (score > 0) {
			if ((score & 1) == 1)
				b++;
			score = score >> 1;
		}
		newscore += b;

		return newscore;
	}

	public enum Suit {
		D, H, C, S;
		public static Suit fromChar(char c) {
			switch (c) {
			case 'D':
				return D;
			case 'H':
				return H;
			case 'C':
				return C;
			case 'S':
				return S;
			}
			return null;
		}

		public static Suit fromStr(String a) {
			return fromChar(a.charAt(a.length() - 1));
		}
	}

	public enum Rank {
		r2, r3, r4, r5, r6, r7, r8, r9, r10, J, Q, K, A;
		public static Rank fromChar(char c) {
			switch (c) {
			case '2':
				return r2;
			case '3':
				return r3;
			case '4':
				return r4;
			case '5':
				return r5;
			case '6':
				return r6;
			case '7':
				return r7;
			case '8':
				return r8;
			case '9':
				return r9;
			case '1':
				return r10;
			case 'J':
				return J;
			case 'Q':
				return Q;
			case 'K':
				return K;
			case 'A':
				return A;
			}
			return null;
		}

		public static Rank fromStr(String a) {
			return fromChar(a.charAt(0));
		}

		public int getScore() {
			switch (this) {
			case r2:
				return 2;
			case r3:
				return 3;
			case r4:
				return 4;
			case r5:
				return 5;
			case r6:
				return 6;
			case r7:
				return 7;
			case r8:
				return 8;
			case r9:
				return 9;
			default:
				return 10;
			}
		}
	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {

			reader = new BufferedReader(new InputStreamReader(stream));
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreElements()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (Exception e) {
					// TODO: handle exception
				}
			}
			return tokenizer.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}
	}
}