TopCoder Statistics - Problem Statement

Problem Statement

You are developing the matchmaking component of an online dating site. Prospective members must fill out a questionnaire consisting of binary questions such as Do you prefer to vacation (a) in the mountains or (b) at the seaside? and Would you rather travel (a) by plane or (b) by train?

You are to match up men with women by maximizing the number of answers each couple has in common. A man and a woman have an answer in common whenever they give the same answer to the same question. Conflicts can easily arise due to numerical ties, but you will be able to resolve all such conflicts using the following procedure. Note that there will be equal numbers of men and women, with names being unique in each sex.

Take the woman whose name comes earliest in lexicographic order, and consider the men with whom she has the greatest number of answers in common. Among these men, pick the one whose name comes earliest in lexicographic order. You have found the woman's best match. Remove this couple from the dating pool, and repeat the matching procedure until there are no more singles left.

You are given a String[], namesWomen, containing the names of single women, and another String[], answersWomen, containing their answers. The kth element of answersWomen lists the answers of the woman whose name is the kth element of namesWomen. If there are n questions in the questionnaire, then every element of answersWomen consists of n characters, each of which is either 'a' or 'b'. The answers are always given in the fixed questionnaire order. You are similarly given the String[]s namesMen and answersMen for the single men. Lastly, you are given a String, queryWoman, containing the name of a woman. Return the name of the man to whom she is matched after you have formed all couples according to the above rules.

Definition

Class:: MatchMaking
Method:: makeMatch
Parameters:: String[], String[], String[], String[], String
Returns:: String
Method signature:: String makeMatch(String[] namesWomen, String[] answersWomen, String[] namesMen, String[] answersMen, String queryWoman)
(be sure your method is public)

Notes

Lexicographic order is like dictionary order, with the difference that case matters. All uppercase letters take precedence over all lowercase letters. Thus, "boolean" comes before "boot"; "boo" comes before "boolean"; "Boot" comes before "boo"; "Zoo" comes before "boo".

Constraints

namesWomen contains between 1 and 50 elements, inclusive
if namesWomen consists of n elements, then answersWomen, namesMen, and answersMen consist of n elements each
each element of namesWomen and each element of namesMen is between 1 and 50 characters long, inclusive
the only characters that may appear in namesMen and namesWomen are 'a' to 'z' and 'A' to 'Z'
no two elements of namesWomen are alike
no two elements of namesMen are alike
the first element of answersWomen is between 1 and 50 characters long, inclusive
if the first element of answersWomen consists of m characters, then each element of answersWomen and of answersMen is m characters long
the only characters that may appear in answersWomen and answersMen are 'a' and 'b'
queryWoman is one of the Strings in namesWomen

Examples

{"Constance", "Bertha", "Alice"}

{"aaba", "baab", "aaaa"}

{"Chip", "Biff", "Abe"}

{"bbaa", "baaa", "aaab"}

"Bertha"

Returns: "Biff"

Alice has two answers in common with Chip and three answers in common with both Abe and Biff; Abe gets lexicographic preference. Bertha also has two answers in common with Chip and three answers in common with both Abe and Biff. Since Abe has already been matched to Alice, Bertha lands Biff.
{"Constance", "Bertha", "Alice"}

{"aaba", "baab", "aaaa"}

{"Chip", "Biff", "Abe"}

{"bbaa", "baaa", "aaab"}

"Constance"

Returns: "Chip"

We are dealing with the same names and answers as before. Constance is the last to go. Although she has two answers in common with Abe and Biff, they are both taken. She ends up with Chip, with whom she has only one answer in common.
{"Constance", "Alice", "Bertha", "Delilah", "Emily"}

{"baabaa", "ababab", "aaabbb", "bababa", "baabba"}

{"Ed", "Duff", "Chip", "Abe", "Biff"}

{"aabaab", "babbab", "bbbaaa", "abbbba", "abaaba"}

"Constance"

Returns: "Duff"
{"Constance", "Alice", "Bertha", "Delilah", "Emily"}

{"baabaa", "ababab", "aaabbb", "bababa", "baabba"}

{"Ed", "Duff", "Chip", "Abe", "Biff"}

{"aabaab", "babbab", "bbbaaa", "abbbba", "abaaba"}

"Delilah"

Returns: "Chip"
{"Constance", "Alice", "Bertha", "Delilah", "Emily"}

{"baabaa", "ababab", "aaabbb", "bababa", "baabba"}

{"Ed", "Duff", "Chip", "Abe", "Biff"}

{"aabaab", "babbab", "bbbaaa", "abbbba", "abaaba"}

"Emily"

Returns: "Ed"
{"anne", "Zoe"}

{"a", "a"}

{"bob", "chuck"}

{"a", "a"}

"Zoe"

Returns: "bob"
{"F", "M", "S", "h", "q", "g", "r", "N", "U", "x", "H", "P", "o", "E", "R", "z", "L", "m", "e", "u", "K", "A", "w", "Q", "O", "v", "j", "a", "t", "p", "C", "G", "k", "c", "V", "B", "D", "s", "n", "i", "f", "T", "I", "l", "d", "J", "y", "b"}

{"abaabbbb", "bbaabbbb", "aaabaaab", "aabbaaaa", "baabbaab", "aaababba", "bbabbbbb", "bbbabbba", "aaabbbba", "aabbbaaa", "abbabaaa", "babbabbb", "aaaaabba", "aaaabbaa", "abbbabaa", "babababa", "abbaaaaa", "bbababba", "baaaaaba", "baaaaabb", "bbbbabba", "ababbaaa", "abbbabab", "baabbbaa", "bbbaabbb", "aababbab", "ababbabb", "abbaabba", "baabbabb", "aaabaaab", "aabbbaba", "aabaaabb", "abababba", "aabbaaaa", "aabbabaa", "bababaaa", "aabaaaab", "bbbbaabb", "baaababb", "abaabbab", "aabbbaaa", "baabbaba", "bbabbbaa", "aabbbbaa", "abbbaaab", "abababbb", "ababaaba", "bababaaa"}

{"f", "C", "v", "g", "Q", "z", "n", "c", "B", "o", "M", "F", "u", "x", "I", "T", "K", "L", "E", "U", "w", "A", "d", "t", "e", "R", "D", "s", "p", "q", "m", "r", "H", "j", "J", "V", "l", "a", "k", "h", "G", "y", "i", "P", "O", "N", "b", "S"}

{"bbbaabab", "bbabaabb", "ababbbbb", "bbbababb", "baababaa", "bbaaabab", "abbabbaa", "bbbabbbb", "aabbabab", "abbababa", "aababbbb", "bababaab", "aaababbb", "baabbaba", "abaaaaab", "bbaababa", "babaabab", "abbabbba", "ababbbab", "baabbbab", "babbaaab", "abbbbaba", "bbabbbba", "baaabaab", "ababbabb", "abbbaabb", "bbbbaabb", "bbbaaabb", "baabbaba", "bbabaaab", "aabbbaab", "abbbbabb", "bbaaaaba", "bbbababa", "abbaabba", "bababbbb", "aabaaabb", "babbabab", "baaaabaa", "ababbaba", "aaabaabb", "bbaaabaa", "baaaaabb", "bbaabaab", "bbababab", "aabaaaab", "aaaaabab", "aabbaaba"}

"U"

Returns: "x"
{"i", "a", "d", "m", "g", "c", "n", "f", "b", "h", "k", "e", "j", "l"}

{"babbabaaaabbbabbbbaaabaababb", "baaabbaabbbbbababbaababbbabb", "aabaaaaabbabbbababbbbabaaabb", "babbaaabbababbaaaaaaabbbaaaa", "abbbabbbaaaabbaabbaabbbbaaaa", "abaaabababbabbbbaabbbaaabbaa", "abbbaaaabbabbaaaaaaaababbbab", "ababbaaaabaababaaababababbaa", "abbbbaaabaabbabaaabbbaabaaab", "abaaabbbaaaabbabaaabbaabbbbb", "bbabaabbabbbabbabaaabbbabbbb", "bbabbabbbbabaababaabbbbbaaab", "aaababbaabaabbbbbabaabaaaaaa", "baaaaabbbaabbbbabababbbabbab"}

{"g", "n", "a", "m", "e", "h", "l", "b", "k", "d", "f", "i", "j", "c"}

{"bbbabbbbbaabaaabbbbbbaaaaaab", "aabbaaabbababbbaaababbbaaaba", "bbbabaabbabbbbbaaaaabaaababa", "bbaabbabaaababbbbababbaaabab", "baaaabbabaabbabbaaaabbabbaba", "abbaaabaabababbbabababababab", "baaaabaaaababbaaaabababababa", "bbaaaaaababbaaabbbbaaaabbabb", "aaababbaaabaabbaaaaabababaab", "baaaabaaabbbabbabaaaabbabaaa", "abbbaabaaabbbbbabbbaaababaaa", "bababbbabbaababbbbbbbabababa", "bbabbbaabbbbaaaaaaababababab", "baaabbbabaababababbaaaaabbaa"}

"l"

Returns: "c"
{"a", "f", "c", "h", "g", "d", "b", "e"}

{"aababbabaabbbabaabaaabbbababbaaaaabbbabb", "aaabbabaabbaaaaaaabbabaababaabbbaabbaaab", "abbbaabaababababbaababbaabaaabbaabaabbab", "bbbbaaaaaaaaabbbbbaaaabbaababbbbabbaaabb", "aabbbabaaaabbbbaabaaaaabbaaababaabbbaaab", "baaaaaabababbababbaaaaaaabababaabaabbbbb", "aabaaaaaabaabbbabaabababaababbaaaabbbbab", "baaabbbbbaaaaabbaaaaababbaabbbabbabbabba"}

{"h", "d", "c", "a", "f", "b", "e", "g"}

{"baabaabbbaaabaabbabaabbaaaabbbabbbaaaaba", "baabbaabbbaaaabaabbbaaaababababbbaaaabaa", "abbababaaaabaabbbabbbbabbaabbbbbbabababb", "bbabbaaaabbababaaaaabbabbbabaabbbababbaa", "babababbbbbbabbaabbbbbbaababbbbbabbaaaaa", "babbbbbabaaabaaabaababbaabababbababbbbbb", "abaababaabaaaabbaaaaaaaabbbabaaabbbabbab", "abbaabaaaabbabbbaaabaabbbaabbbababbaaabb"}

"a"

Returns: "g"
{"g", "h", "c", "t", "j", "o", "u", "y", "x", "p", "w", "i", "r", "f", "l", "n", "m", "k", "v", "b", "s", "z", "e", "d", "q", "a"}

{"aabbbbbbbababbabbabbaabaababa", "aaaaaaaaababbbbaaaaaabaabbbbb", "baabaabaabbaabababbababbabaaa", "ababbbabbabababbbbbabbbabaaba", "aaabbababaaaaababbbabaabaaaab", "bbbbabaabbbbaaaababbaaababbab", "aabababaabababbaaabbbabaababb", "abbbabbaaaabaabbbbababbbaaaab", "abbaabbbabaabaabaaabbabbabbab", "baabbabbababbaabbaabbbbbbbbba", "abbabbabababbbbbbaaaaababbbab", "bbababbbabbbbaaabbbabbaaababb", "baabbbababbbbbbbaabababababbb", "bbbaaaaaabbaaaabbabbabababbbb", "baaaabbbababbbababbaabaababbb", "bbbbbbbabaababbababaabababbab", "abbbbbbaaabababbbaaaaaabbabba", "bbbbbabaabaabbaaaaababbbbabaa", "bbabbaaaabbaaaababbabaaaabaaa", "baaabbbaaabbabbbbbbabbbababba", "babbbbbbabbaabaaabbbabbababbb", "bbaaaaabababaaaaabaabaabaabba", "bbbbbbbaaabbaabbaaabbabbbbbbb", "baaaaabbbabbabababaabaababaab", "baaabbbababaabaababababbaaaba", "abbaabbababbbabaabaaaaabbbbaa"}

{"n", "q", "b", "v", "m", "g", "k", "f", "h", "c", "t", "d", "r", "w", "p", "i", "o", "y", "l", "s", "a", "u", "x", "e", "z", "j"}

{"bbaaaaabaabbabbaabaabbababaab", "aabbaaaaaaabbaabaaabababbaaaa", "bbbbabaabaabaaabbbaababababbb", "bbabbaaabbbabaaaabbbbbbbaaabb", "abbaaaabbaaabbbabaaaababbaabb", "aababaaaaabaaaaaaaaabbaabbaab", "ababbabaabaabbbaabaaabaaaaaab", "bbbaabbbaaabaaabbabbabbaabbbb", "bbbaaaababaaabbaaabbbbbaaabab", "baabaaaaabbaaaaaababbabbbabab", "bbbbbabbbabaabbbbbbaaabbbbaaa", "aaaaaaaabbababbaaabbabababbba", "bbbaaaabbabbaabababbabbaabbab", "bbbbaabaaabbababababaabaababa", "bbbbbaaabbaabbbaabaaaabaabbaa", "bbbaababbbabaababbbbbaabbbaaa", "bbbaabaababaabbbaabbabaaaaaab", "aabaabbbbaabbababbbbbaaaaaaba", "baaabbaaabbabaaaabbaabbbaabab", "bbbabaaabaaabaaabbabbbaaabbbb", "bbaabbabbbbaaabbaaaaabbbbbbbb", "baaaaaabababbbbaababbbbbbbbab", "bbaaaabbaabbabababbaaabbaaaab", "aaaababbabaaaabaaabbaabababba", "ababaaababababbbabbbbbbbbaaba", "bbbbabaabaabbbabaabbbabbaabba"}

"j"

Returns: "k"
{"i", "t", "h", "d", "y", "f", "k", "o", "q", "l", "n", "g", "m", "s", "x", "p", "w", "r", "b", "c", "v", "z", "e", "a", "j", "u"}

{"bbabababbaba", "baaaaabbabaa", "bbbbbbbbbbbb", "baabbbbababb", "abababaabbbb", "babbbabbbbab", "abbabaabbbbb", "abaaabababba", "babbaabbabaa", "babaabaaaaba", "bbbaaaababaa", "babbabaabbab", "bbaabbbaaaab", "aabbaabbabaa", "baaabababbaa", "aaababababbb", "baaaabbabbba", "aaaabaabbaaa", "babbbbaaabba", "bababbbaabba", "aabbbabbbbaa", "abbaaaaaabaa", "babbabaaaabb", "bbbbbbbaaaba", "abaaaaabaabb", "babbabaaaaaa"}

{"y", "b", "j", "e", "r", "h", "c", "i", "d", "u", "x", "f", "t", "l", "g", "s", "o", "z", "m", "n", "k", "w", "q", "a", "v", "p"}

{"aaaaaabbabba", "aabbbabbbaaa", "bbabaaaaaabb", "baabbbbbbbab", "bbaaaababbab", "aabaabbbbaba", "bbbabbaaaaba", "aabababbbaba", "bbaaabbbbaba", "aaabaababaab", "bbaabbaabaab", "bbaabbaabbab", "aabaabbaaaaa", "aabbababbaba", "baabbabaaaba", "baaaabbaaaaa", "aabaabaabbab", "bbababbbbbab", "bbbaaabbbaab", "baaabbaaaaaa", "babaabaababa", "baabbbbbbaba", "bababbabbbab", "bbaaaabbbaba", "abbbbbbbbaaa", "babaaaaaaaba"}

"o"

Returns: "y"
{"J", "a", "h", "m", "C", "y", "A", "v", "D", "u", "s", "M", "O", "j", "e", "Q", "z", "w", "d", "t", "l", "L", "c", "x", "f", "n", "g", "F", "k", "G", "I", "r", "B", "q", "o", "N", "b", "P", "K", "E", "H", "p", "R", "i"}

{"baabaabbbbababba", "bbaaababaabbabba", "abaaaaabbaababbb", "bbaababbababbbbb", "bbaabaabaababbab", "abaabbbbbaabaaba", "baaaaaaaabbbbbaa", "ababaaaaabbabbba", "bbaabbbabbbaabaa", "aaabaaaabaaaaaaa", "abbababbabbbbabb", "aababbabbaaaabba", "bbbbbbbaabbbbbbb", "babbbabbbbbaabba", "bbbabaaaabbbbbaa", "abbababaabbaaaab", "bbabbababaabbaab", "aaaaaabbabaaaabb", "aaababaaababaaaa", "baabbaabaabaabab", "bbaabbbaabababaa", "bbaaabbbbbbaaabb", "abbbaababbabbabb", "aabaaaababbabaaa", "aaaaabbbbabaabab", "aabbabaabbabbbab", "bbbbbbbabaabbbba", "abbbaabbbaaababa", "aababababbbababb", "aababaaabbbbaabb", "bbbabbbaaabbbbbb", "aabbbaabbabbbaab", "babbbbbbbbbbbaaa", "baabbabaabababaa", "bbabbbbbbaaabbbb", "babaababaaaaaaaa", "aabbabbbaabaaaaa", "bbbbbbbbbaaaaabb", "aaababbabbbaaaab", "abaaabbbbbaaabba", "bbbabaabbababbbb", "bbabaaabaaababab", "abaaaabaaabbbaba", "ababbabababaabab"}

{"R", "I", "b", "a", "A", "o", "q", "B", "x", "n", "y", "g", "r", "C", "O", "K", "Q", "G", "c", "k", "p", "D", "P", "m", "N", "i", "E", "e", "l", "M", "f", "d", "j", "u", "F", "z", "J", "t", "w", "h", "L", "v", "s", "H"}

{"abbbbaaaaabaabba", "bbaabbaaabbbbabb", "abbabbababababba", "babababbbbbaabba", "baabbbbbabbbbabb", "bbbababbbbbbbbba", "bbbabbbaabbababa", "aaaaabaabaaabbba", "bbbbabbaaabbabbb", "babaabaabbaabbba", "abaabbbbbababbab", "bbabbbbabbaaabaa", "abbbabbaabbababa", "ababaabaaabababb", "abababbabbaabbab", "babaaabbabababaa", "bbbaaaaababbbaaa", "bbbbbaabbbbbaaab", "bbbbaaaababaabba", "bbababbbaababaab", "bbaababbbbbaabbb", "abaababbbbbbbbba", "bbaaababbaaababa", "baabbbaaababaaab", "abababbaababbbab", "baaabababbaaaaab", "ababbabbbbabbaaa", "babbbabaaaababaa", "aabbabaabbaaaabb", "bbbbabbbbabbbbaa", "babaaaabbabbabab", "baaaabbbbabbbbba", "abbaaababaaabbaa", "baaabbbbbaababab", "abababaaaabbabbb", "bbbaababbbbaabaa", "bbabaaaaaababbaa", "abaaaabaabaaaabb", "aaababaaaaabaaab", "abbabbaabbbbbabb", "aaaaaaaabbbabbbb", "aababbabaaaabbbb", "bbbbaaaabbababba", "baaaaababbbabbab"}

"M"

Returns: "v"
{"k", "j", "f", "h", "a", "d", "n", "b", "e", "l", "c", "i", "g", "o", "m"}

{"ababaa", "abbaaa", "abbabb", "ababbb", "ababbb", "abbaba", "bbbbab", "abbaba", "baabaa", "bbbbbb", "aababb", "aaabba", "bbbabb", "abaaab", "babbbb"}

{"k", "h", "d", "i", "o", "g", "c", "j", "f", "m", "l", "n", "a", "b", "e"}

{"ababaa", "aaaabb", "baabab", "abbbab", "baabbb", "aaabaa", "baabab", "aabbbb", "bbbaaa", "bbaabb", "abbbaa", "ababbb", "bbbbba", "babbab", "aaabab"}

"j"

Returns: "l"
{"G", "c", "u", "N", "k", "b", "s", "h", "H", "E", "y", "D", "d", "F", "f", "O", "J", "o", "I", "i", "p", "r", "a", "L", "B", "n", "C", "z", "v", "l", "A", "e", "K", "q", "P", "j", "g", "w", "m", "M", "x", "t"}

{"aabaabaabbba", "abaababbbaba", "abbbabbbbaab", "aabbabbbbabb", "aabbbbbababa", "ababbabbbaba", "abaabbbabaab", "babbbbbbbbab", "babbaaaaaaba", "bbababbbabbb", "babababbbbba", "abbbabbbbaab", "bbbaaaabaaaa", "aababbbbbbaa", "aabbabbaaaaa", "babbbbabbaaa", "aababbabbaaa", "abbaababbaab", "abbaababaabb", "bbabbaabbabb", "aaaababbbbbb", "abbbbabbaabb", "baabaabaabaa", "bbabbbbbabaa", "bbbbbabbaaba", "aababbbbbaaa", "baabbbbbbabb", "ababbabaabba", "bbaaabbaabab", "abbbaabaaaab", "bbabbaababba", "bbbabbbabaaa", "bbbbbbbabbab", "abababbaaabb", "aabbaaaababa", "baaabaaababa", "abbbaabaabab", "aaaaababbabb", "ababaabaabbb", "babbbabababa", "bbabbabaabab", "bbbabbbabaaa"}

{"q", "u", "b", "I", "v", "w", "s", "M", "h", "z", "J", "P", "y", "t", "K", "H", "d", "G", "C", "F", "D", "x", "N", "r", "a", "c", "g", "i", "n", "A", "o", "m", "l", "k", "L", "f", "E", "e", "B", "O", "p", "j"}

{"aaabaabbaaba", "aabababbbabb", "babaaaaabaab", "bbbbabbbbabb", "abbbbbaaabaa", "baaababaabaa", "babbabbaabab", "abbabbababbb", "aaabbbaaaaba", "bbbbbbabbabb", "baabbbabbbba", "babababbaaab", "bababbbbabbb", "bbaabbababaa", "bbabbbaaaaaa", "babbbbbabbbb", "abaaabbababa", "aaabaabaaaab", "babbababbaab", "bbaabbababaa", "bbaaaaababbb", "aabbbaaaabbb", "aababbbbbaaa", "abbabbaabbbb", "baabaaaabbba", "aababbabbabb", "bbabbbbbaaba", "abaabbabaaab", "ababaabaaaba", "baaabbbbbbba", "baababbaaaba", "bbbaaabaabbb", "ababbaaababb", "babababaaaab", "bbaabbaababa", "abbbaaaaaaab", "abaaaababbbb", "bbabaabbbbba", "abaababbaaba", "baababaababa", "abaaababbaba", "baabbbababba"}

"x"

Returns: "e"
{"g", "c", "e", "h", "a", "d", "f", "b"}

{"bbaaabba", "bbbbbaab", "aaaababb", "babababa", "bababbaa", "bbbababa", "bbaaaabb", "bbaabbab"}

{"e", "a", "h", "f", "c", "d", "g", "b"}

{"bababbab", "abaabbab", "aaaaaaab", "aaaaabaa", "baaabaaa", "bbabbbbb", "bbbabbba", "abaaaaba"}

"h"

Returns: "c"
{"p", "H", "v", "E", "k", "q", "j", "t", "f", "B", "g", "c", "C", "b", "x", "e", "J", "h", "O", "Q", "S", "s", "w", "I", "M", "D", "r", "R", "z", "P", "K", "d", "N", "n", "y", "L", "m", "G", "i", "u", "A", "o", "l", "a", "F"}

{"bbbbbabbaabaabb", "bbbbbabbbaabbab", "abaaaabbbaaaaaa", "ababbabbaabbabb", "aabababaabaabbb", "baabaababbbaaab", "bbbabbbbbbbbbbb", "aaaaaababababba", "aabbbbaaabbbaaa", "abbababaaabaaab", "aaabaaabbbbbbab", "aaabaaaaaabbbaa", "abaaabbbbbbaabb", "bbbbbbbabbbabba", "aaaaabbbababaab", "babbbbbbaabaaba", "abbbaaaaabbbbba", "abbbabaaabaaaba", "baabbaabbababab", "abbbababbbbbaab", "bbabbabbaabaaaa", "abbabbbbaaababa", "abaababbaaaabab", "abbaabbaaabbabb", "babaaaaababaaba", "bbbababaaaaabba", "ababaaaabaababa", "aaababbaaababba", "abbabaabbabbaab", "bababbabbbbbbbb", "aaaaaabbbbababb", "aababbabbabaabb", "babaababaaabaab", "aabbaaaaaababbb", "aabbaaababaaaab", "aabbaababababab", "babababbaaabbbb", "bbaabbabbabbaba", "aaaaababbbbbbba", "aaaaaaabababbba", "aaaabbbbbaababb", "aabaababaaababa", "babbabaaabababb", "aaaaabbbbabaabb", "aababbbaaababbb"}

{"h", "u", "t", "F", "c", "r", "n", "O", "Q", "A", "P", "l", "J", "S", "s", "C", "x", "y", "w", "o", "j", "R", "H", "E", "g", "e", "a", "d", "q", "k", "L", "v", "i", "D", "p", "N", "B", "K", "z", "m", "f", "M", "G", "b", "I"}

{"babaabaaabababa", "aaaababaaaabaaa", "ababbaaabaabbbb", "babbbaabaaababa", "bbbbabbaaaababa", "ababbabbbbbabba", "bbbbababbbaabba", "baabbaabaaabaab", "baababaaababbbb", "bbbaaaabbbabaab", "abbaaabbaaaaaaa", "aababaabaaabbba", "babbbbaabbabbaa", "abaaaabbbaaaaba", "baaabbabbabaabb", "aaaaaabbababbab", "bbbabbabbabbaab", "abbaaabbbabbbaa", "bbbbabaaaaabbaa", "bbbbbaababbabba", "abbabaabbabbbaa", "baaaabbaabbbaab", "baabbaaabaaabab", "abaaabbaabaabab", "aabbbbaaababaab", "aabbbabbbbbbbbb", "aaaaaabaaababaa", "bbabaaaaaaabbbb", "babbbabaabbbaaa", "aaabbbbbbabbaab", "baabababaababaa", "bbbaaabbaabbbbb", "baabababbababaa", "abbbbababbbaaba", "babbbabaaabbbaa", "baabbaababbbbaa", "babbbbaabaaaabb", "abbbbbaabaabaaa", "abaaabaababbbbb", "bbbaaaabababaaa", "bbaaaaabbbbbbaa", "abaaaaaabaabbbb", "aabbbbabbbabaab", "aaaabaabaaabaaa", "babbabaaaabaaba"}

"M"

Returns: "I"
{"C", "j", "i", "S", "p", "G", "K", "n", "A", "r", "s", "O", "J", "R", "q", "o", "B", "z", "y", "H", "d", "F", "c", "x", "w", "g", "k", "u", "D", "m", "Q", "M", "e", "f", "P", "b", "h", "L", "v", "t", "E", "a", "I", "N", "l"}

{"bbaabaabbbabaabbaaabbbbaaabaaab", "aaaabaababbabbaaabaabaabaabbbaa", "bbbbaaabaaaababaaaabbbabaaaabaa", "baaabbabababbbabbaaaabbabbaabab", "baaaaababbbbabaaaabababaababaab", "abbababaababbbaaabaabbbbbabbbbb", "aabaabaaaabbbbababaababbabbbbab", "ababbaababababbaabbbbbabbbbabbb", "aabbbbbbbaabbbbababbaabaaabaabb", "aaaabaaababbbaaabbababaaaaabaaa", "ababbabababaabaabbbbabaababaaab", "aabbbbbaaabbaabbabaaaaaababbbab", "ababbbaabbaaabaababababaabaabaa", "aabababaabbababaabbbabaabbaabaa", "bbbaaaabaabbbaabbabbababbaabbbb", "babaabbabaababbbaababaaababbaba", "aaaaababbbbabababbabbbbbbbbbbba", "bbabbbaababbbabbaaabbbaabbbaabb", "aaabaabbbbbbababbbaaaaababbabba", "baaabbaaabababababbaabbabbbabbb", "aababababbbaabaaaaaabbbaabbabab", "bbbbababbbaabaaaabababbaaabbbbb", "baababbabaabbbabbbbbbbaaabaaaab", "aaabbaababbbaabbbaaaaabbbbaaaaa", "aaabbbbaaaababbabbaabbbaaabbaaa", "aabbbaaaabbbaabaaaabbbaaabaaaaa", "aababaabababaabbbabbbbbbbbaaaba", "ababababbababbaaababaaababaabab", "baababbabbbaabaababbaabbaabbbbb", "baaabaaaababbabaaaabaaaaaaaaaaa", "abbaaaaabbabbaaabbbbaababababbb", "aaaaabbbbabaaaaaaaababbbabbabbb", "aaabbaabaabbbaaabbbaaabaaaaaaba", "ababbaaaaabbbbbbbaababbababbbba", "abaaabaaabaaaaabaabbbbbaabbaaba", "babbbaabbabbbaabbbaaababbbbabbb", "aaababbaaabbbabababababababbaab", "abaabbaaababbbbbbbbbbaaaaaabbbb", "baabbaaabaaabaaabbaabaabbaabbaa", "babababaabbbbaaabbbabaaaaaabbbb", "aabbbaabbaaaababaaababababbaaab", "bbbbaabaaaaabaababbbabbaabbabab", "aabbabbabbbaaabbbbabbabbbabaaaa", "baabbaaababaaabaababbbaaabbbaab", "bbbabbbbabbbabbababbbbbabaababa"}

{"a", "q", "P", "h", "D", "g", "n", "B", "t", "L", "z", "J", "H", "K", "e", "b", "u", "Q", "I", "o", "E", "j", "d", "r", "F", "C", "v", "G", "k", "l", "y", "f", "s", "R", "p", "i", "x", "S", "w", "N", "c", "A", "m", "O", "M"}

{"abbabbabaababbabaabababababbabb", "abaabbbbabbabbaaaabbbbaaaababba", "abbaaaabbbbbabaabababaabbabbaba", "babaabaaaabbaabaabaabaabaabaabb", "baabbaaababababbbaaabbaaaaaaaab", "aaabaaabaaabbaaabbbaaaaabbabbbb", "bababaababbaabbbbabbbbaababbbba", "babbabbbbbabbbababbbbbaaabababa", "aaabaaababbaaabbbabaabbaabbbbab", "babaababaaabaaabbbabbbbbbaaabaa", "abaabababbbabaaaabaaaabaaabaaaa", "baabbbaababababbaabababbbbbbaba", "bbaabbbaabaabbaabbaabbbbaaabaaa", "aaaaabbbbaababbabbbbbbabbaabbbb", "babbaabababbbabbabbaaaaabbbbaab", "bbaaabababbabbbbabaaabbaababaab", "abaaabaababbaabaabbbbabbbbbabba", "bbbbbaaaaaabbbabaababaabbabaabb", "bbbabbbbbaabababaabbabaaaabbaaa", "bbbbbaaabbbbaabbaaababbbabbbbba", "baabbbabaaabbbbaabaaababbbbbbaa", "abaabaaaaaabaaaaaaaaaaaaaabbbaa", "abababbaaababaabaabbabbabaabbbb", "aababaabbbaaabababbbbbaaabaabba", "abbaabaabbaabbaabaaabbabbbabbba", "aaabaabaaaabaababbbbbbbaabbabaa", "aabbabbaaaaaaaaababaaabbbbbbbbb", "bbbabbaabaaaaabbbaabababbaabbab", "bbaaabaaaaabbbabaabbbabbaabbbab", "abbbaabbbaaaaabbababbaabbbaaaaa", "bbaabbbbabaaababbbbaaaabaaabbbb", "babaaabbabbaaabbaaaabaabbabbbba", "abababaabbbaabbaabaaaabaababbba", "bbbbabbaaabaabaaabbaaaaaaaabbab", "abbaaaaaabbaabaaabaaaabbabababa", "babaababbaaaaabbabbbbababaabbbb", "babbabbbbabbabbbbababbababaabbb", "baaaabaabaaaaaababbbaaaaabaaaba", "baabaabaaaabaabaabaabbaaababaab", "aaabbaaaaabaabbbbaabaabbabbbbaa", "bbbbbaaaabbbaabbbbaabbbbbaaaaaa", "bababaabaaaababbababbaaaaaaabbb", "bbbaabaaaaaabbaabbaabbaaaabbaba", "abababaabbbabbaaabbaaaaaabbbabb", "abbbababbabbabaaabababaaababaaa"}

"Q"

Returns: "g"
{"y", "f", "j", "t", "b", "l", "v", "o", "u", "a", "m", "g", "x", "p", "c", "e", "k", "z", "r", "s", "n", "d", "i", "q", "h", "w"}

{"bbbabbbababababbbaabbaabbbbabbbba", "aabaabaaaabbbababaaababbabbaabaaa", "abaaabbaabbbbbabaaaaaaaabababbaba", "aabbbbbbababaabbaaabaabbaaaabaaba", "aaababaaaaaaababbabbbababbbbbaaba", "abababababbaaabbbbbbbaabbbaaaaaba", "aabbbbbbbabbbabaaababaabbaaaaabba", "bababbbbbbaaaabaabbbbabaaaabbbaab", "bbaaabbaabaaaababbabbabbbababbaba", "bbabbaabaabbaaababbbababbbbbabaaa", "baaaababbbbbabaababbaaaabbbaaabbb", "baaabbbbbaaaababbaabbabaabaabbabb", "babbbbbabbbbaaaababbbababaaababab", "bbabbbabbbbaabbaaabbabababbaabbba", "abbabaaabbaabaabaaabbaaaababbbaab", "abaaaaaaaabbaaaaaaaabaababbbbabbb", "aabababbbaabbaaaabbaaaaaaabbaabab", "bbbbbabbbabababababbaabbabbabaaab", "bbabbabaabaaabbaaabaaaabaaaaaabbb", "babbbabaaabaaaabbbbbbbbbbabbbabaa", "bbaaaabaaaaabbaaabbaaababaabbaabb", "aaabaabaabaabaabbaabbaaaaabbaabab", "aabaabaabbbabbabbbbbbaabbbaaabaaa", "aaabbaaaabbbbabababbbbbbbbabbbbba", "babbaaaaabbbababaaababbbabaabbbab", "bbabbaabbbaaabbaaaaabbbaabaababab"}

{"d", "v", "k", "x", "f", "c", "m", "b", "o", "q", "z", "t", "e", "y", "g", "a", "l", "h", "w", "r", "s", "i", "n", "u", "p", "j"}

{"abaaababbaabbbabbbabbabbaabbaaaab", "abaaabbaabaabaaaababbbababbbbaabb", "bababaabaaaabbbabbaaaabbabaaaaaba", "abbbbbbabaaaababbbaababbababbabba", "abbbaaaaababbaaabbbaaaabaabbababa", "babaaababbabbaabbbbabbababbaaaaba", "bbbbaaabbababbaabaabababbabbbbaaa", "abbabbbbbabbbaabaaabaaababbbbbaaa", "ababaaabbbbbaaabaaaaabbabbbbbabab", "babaaaaaabbbaababbbbaabbabbababba", "aabbbaaaaaaaabbbbbbbaaaaaabbbbaaa", "baababaaabaabbbaabababaaaaaaaabab", "aabaabaaabbbbaaaaaaabaaaaaaabbaab", "baababaaaababbbabbabaababbbaaabbb", "bbbbbbbaababaabbabababaababbbabbb", "baaababbbbabaaababbababbbaaaaaaaa", "babaaababbbbbbababbaabbbabbaaaaba", "bbaabbaaaabbabaaabbababaabbbaaabb", "aaaaaaaaabbbbaababaabaaaaabaababa", "ababbbaaabbaaaabbabbbbbabaaabaaba", "bbbababababbabbaabbaaabbaaabababb", "aabbbbababbababbaaabbbabaababaabb", "abababaabbbaabbababbabbaaaabaabba", "baaaaaaaababaabaabbbaabaababbbbba", "aaaaaabbaabababaababbbbbaaaabbbab", "abbbbaaaabbababbabbaaaaaabbaabaaa"}

"q"

Returns: "q"
{"i", "p", "a", "l", "e", "h", "j", "n", "o", "k", "b", "m", "c", "f", "g", "d"}

{"aaaabaabbbbbabaaabbbaaaabba", "bababbbbaabaaaabaabaabbaabb", "bbbabaabbaaabababababaaabbb", "bbbabbaabbaabbbbbabbbbbaaba", "aabbbababaaaaabbbbbbbaabbab", "bbabbbaaaababaaaaabaaaaaaaa", "aaabbabaabbaabbbbbbaabbbabb", "bbaababaaaaabbbbabababbbbaa", "bbaaaabaaabbbaabbbbbabbbaba", "aabbbbbaabbabbabbbaaabbbaaa", "bbabbbabaaaabaabbaaaabbbaba", "aababbbbaababbaabbbbabbaaba", "aaaabbbabbabbbbaaabbaaaabba", "abbaababaaaaaabbabbaabbabaa", "abbbbaabbabbbaaabbaaaaaaabb", "aabaabbaabbbabbbabbaaaabbab"}

{"c", "j", "g", "m", "n", "o", "b", "f", "p", "a", "e", "h", "l", "i", "k", "d"}

{"babbaaaabaabbbbababababbaba", "bbbabbabbbabbbaababbababbba", "baabaaabbaabbabbbaaabbabaaa", "bbabaaaababbabaaaaabaabaabb", "bbababaabbbababbbabaaabaabb", "aabbaabbaabbaaabababbbbbbba", "abaaabaaaaababbbbbbbabbbaba", "bbaaaaabbbbaabbbaabbaaababb", "bbaaaabaabbbaaaaaabaaaabaaa", "aabaabbabbbbabaababababbaab", "abbbbaababbababbababbabaaaa", "bbbbbaabbbbaabbbbaaabbaabba", "ababbbaabaabaabbbaaabbabbba", "aaaababaaaaababaabaabbbbaab", "aaabbbbaaabababaaaababaaabb", "bbbaaaabbabbbabaababbababbb"}

"i"

Returns: "f"
{"g", "f", "k", "m", "c", "b", "h", "i", "j", "l", "d", "e", "a"}

{"baabaabbbaabaaabbbbbaaaabaabbbaaab", "aaabbababbbbbbbbbaabbbabbabbbaaabb", "babaaabbbababaaabbaaaabaababaababb", "bababbaababbabbabbaabbbaababaababb", "bbbbaabbbaabbbabbabbababbabbbababa", "aaabaabbabbbabbababbabbbaabbaaabbb", "babbaaaababaabbabaabbbbabbabbbbabb", "abbabaaaaabbabbbaabaaaaabaabababba", "aabbbaabbbababbabababaaaaabbbaaaaa", "aabbaabbbaabbbbbaabbbababaaaabbbab", "aaababbabaaabbbbabaabaabaababababa", "bbabbabababbabaaababaaabbbbabbbaba", "bbaabaaabbaabbbbbabbabababaaaaaaaa"}

{"g", "h", "m", "i", "c", "l", "b", "e", "a", "f", "j", "k", "d"}

{"babbbababbaaaabaabbaababbabaaababa", "aabaabaaabbbababbbbaaaaabbabababba", "babababaabbbabbabbbaabbbabbabababa", "bbbbaabaababaaabaaaabbbbbbbbaaabaa", "abaaabbbabbabaaabaaabaabaaabbbbbbb", "ababbbaabaaababaabababbbbbbbabbbba", "aaaaabaaaaabaaabbaabbabbbbbaabaaaa", "baababbaaaaaaaaaaabbbabbabaaabaaaa", "bbbbaabaabbaabaaaaabbabbaaabaabbaa", "aaabaabbbbaaaaabbabbabbaaaaaaaabaa", "babbbababbbababbbababbabaaabaabbab", "babaaaaaaaabaabababababaaabaaaaaaa", "babbaabbabbbaaabbaaababbaaaaabaaaa"}

"h"

Returns: "e"
{"r", "e", "x", "c", "G", "i", "z", "a", "b", "n", "l", "p", "D", "d", "m", "s", "v", "q", "f", "g", "o", "t", "F", "A", "w", "E", "B", "C", "H", "j", "k", "y", "u", "h"}

{"bbaaaababbabbabaabaaaabbaaababbbaaaabbbbbbab", "baaababbabbabbbbbaabababbaabbbaaababbaabbabb", "bbabaabbbaaabababbbbbbaaaaaaabbbababababbaaa", "bbbaabaababababbabbbbaabbbabbabababaabbaabba", "baaaabaabaabaababbbbabbaababbbababbabbaaabba", "bbbabbbbabbbaababaabbbbbaababaaabbabababbbba", "baaabbaababaaabbbbaabbbbaabbabbaabbbababbabb", "baaababbbbbbbababbababbbabababaababbabbbbabb", "abbbabbaabbaabababaababaaaaabababbaabbbbaaaa", "bbbababbbababaababaabbbbbbaabaaababaaaabbbab", "ababbabaaaaaabbaababaababbaababaaabaaabaaabb", "abaabbaaaaaaaabaabaabbaabbbbaaabaaabbaabaaaa", "abaaaaaaaababaabaaaaabbbbaaaabbabaaabbaaabba", "babaabaabbaaaaabbababbbaabaabaababbabbbbaaab", "abababbaaaaaaaabbbbbaaababbaabbaababbabababb", "aabbaaabbbababbabbbbbabbaaabaabbaaaaababbaaa", "abbbababbabababbaabbbaabaabbbbabbbabbabaabaa", "bbbaabbbaaaaabbbbbbaaababbaabbbbaaaaaabbaaba", "abaaababbababaababbaaabbbabbbbabbaaaaabbbbba", "abbaaababababbbabbbaaabababbbbbbbaaaaaabbbaa", "babababaaaabaaaaaabbaabbbbabaaabaaabbabbbbbb", "abbabaabaaabbbbaabbbabbaaabaaabbbbbaaaababab", "aabbbaaaaaabbaaababbbaaaabbababaaaaaabbabbbb", "aabaabbaaaaababbababaaabbbaabaababaaaaabbaaa", "babbbabbabbabbabaaaababaabbaaabbbbbabababbaa", "bababbbaaaabababbaababababbbbbabbabbaabbbbab", "aabaabbaabbaaabaaabaaaaabbbbbaabbbabaabaabbb", "baaaaabbbbbabbbbbbbaababbaabbbabbabbbbbabbab", "aabaababbbaababbbabababbbbaaaababaaaabbbabbb", "bbabbbbbbaabbbabaabbaabbbbabbbabbbbbabbaabaa", "babbabbaaaaabaabbababaaababbaabaabababbaaabb", "babbabaabbbbaaabbbaaaababaaaabbbbabbbaabbabb", "aaaabababaaababbaaabbbabababbbabbbbaabaaaabb", "abbbbbbbbabbbaababbbaabbbbaaabbabbabbbbaaabb"}

{"q", "w", "i", "c", "y", "F", "g", "n", "p", "d", "v", "t", "B", "k", "e", "s", "E", "f", "x", "o", "H", "u", "m", "C", "h", "D", "z", "b", "A", "j", "l", "r", "G", "a"}

{"bbbbbabaaaabbabaabbbbbababbbbbbbaaaabbbaaaaa", "abaabbabaaaabbbabbabbaaaabbabbabababbbaaabab", "bbababbbabbabbabbbaabbbbabababaaabbabaabaaab", "baaaaaabababbbbaaaaaaababbabbabbabbbbabaaaab", "bbbaabbbbaaaaaaaaababbaabbabaababbbaabbabbaa", "aaaabbabaaabababaabbbbbbbbbbbbaaabaaabbbaabb", "abaabbaaababbaaabababbbbaaaababbabbbbbaaabab", "babaabbbaaaabaaaabaaababbbabaabbaaaabbabbbaa", "bbbbbbbbaaaaaaaaababbbbbbbbaababbaabababbabb", "baababbbbaaaaaabbabbbabaabbaaaaaabbbbbbbaaaa", "baababababbbbbabbababbaaabaabbbaabaaabbabbbb", "bbbbbabababaaabaababbbabbbabbaabbabbbaaaaaaa", "bbabaababbaaaaabbaaababababbabbabbbbbbabbabb", "abaaabaaaaaabaaabaabaabbabaaabbbbbaabbabbabb", "aababaababbaabbaaaababbabaaabbababbaaaaaabba", "bbbbbbabbabbaabaaabaabbbbbbaaabaaabaabbaaaaa", "bbaabaaabbbabbbaaababbbbbabababaaabbbbaaabab", "abaabbbbaaabaaabaaaaaabbabaaabbaaaabababaaab", "abbabbabbababbbbbaabababbaaaaabbbbbbbabbabbb", "abaabaaababaaabbbabbabbababbaabbaaabbabbbaaa", "bbbaaabababbabababbababbbaaabaabbbbbabbbbbaa", "bbabbbabbbbbbaaabaababaaaababaabbbaaabaababb", "ababbbbbabbbabbbaaaabbabbabbbaababaababbaaaa", "ababbaabbbbbaabbabbabbaaaabbaabaaaabbaaabbba", "babbabbabababaaaababaaabbaaabbabbaabbbababab", "ababaababaaaababababbbbabbbbbaabbabbabbbbaaa", "abaabbababbaabbaaabbabbaabbbbaabbbaaaaaabaaa", "abbbbababbabaaabbabbbbbabbaabbaabbbababaaaba", "bbbbbaaabbbbbabbaabaababbaabbbbbbabbabbabbaa", "abbbbbbaababaaabbbaaaaabaaaabbaaaabbaabbabaa", "ababbaabbaaabbabbbbababbaaabaabbbbbabbaabbba", "babbbbaaaaabbbabbabbbbbababbbbabbbbbaabbabbb", "bababbbaabaaaabababbababbbbabbaababbbbbaaaab", "ababaabbbbababaaaaabbaabbbbbbaabbbabaababaab"}

"e"

Returns: "i"
{"I", "o", "N", "R", "E", "d", "y", "z", "p", "P", "s", "v", "L", "a", "f", "u", "j", "x", "C", "k", "O", "J", "q", "M", "g", "Q", "e", "l", "H", "F", "w", "r", "h", "D", "A", "B", "t", "m", "c", "b", "G", "K", "n", "i"}

{"babbbbbbbbaaababbabaaaaabbaaabbbaa", "bbbabbabaaabbbbaabaaaaabbaaabbbaba", "ababbbabbaabaababbbbabbaaabbaabbaa", "abaaabbbaababbbababbbaabbbabbbabaa", "bbbbaaabbaababbbabbaabbbaaabbbaaba", "baaabaaaabababaabaaaaaabbbbbaabbbb", "babbaabbabbbaabaabbbaabbaabaaaaaba", "babbbaaabaabbbbbababbbbaabbaaaabab", "babababbbbaaabababaabaaaaababbbaba", "bbbbaaabbbbbbaaaaaaaaabbaaaabbbbaa", "ababaabaaaaaaabbbabbabaabaabababaa", "baabbbbaabbaaabbabbbaaababaaaaabab", "abbaaaaabbabbabaabbbbaaabbbabaaabb", "bbbaaabbbabbbbaaaababaaaabbbbbbaaa", "baaaabbbbababaabaabaaaabbbabbbaaaa", "ababbabaabbbaaabbbababbbbbabbbbaba", "bbabaabbbaabbaaabbbabbaabaaaabbbaa", "babbbbabbbaabaaabbbbaabaaabababbaa", "bbaababbbabbbaabbbabbaaaabbbbaabbb", "aababbbabbbabbaabaaabababaaaaaabbb", "bbbabaaaaabaabbaaabbabbbbaabbbbbab", "abbbabbbbabaaaabbaabbbbbabbababaaa", "bababbbaaabbbbababaaabababababaaba", "aaababbabbaabbbbabbbaabaaabbabaabb", "aabaaababbabbbbbbbbbbbbbbbbbaabbab", "babbababaaabbbaabaaaababbaaaabbbab", "bbaaabbaabbabbbbbbbbaabbbaabaabaaa", "baaaabaabbaabbbbbbbbaaabaaaaabbaba", "aaaabbbbaabbaaaaaaabaabbbaaababbbb", "bbaaaabaaaabbbbaabaabaabaabbaaaaab", "ababbabaaaabbabababbbbbaababbbaaab", "bbaabbbaabbaaababaabbbbbbbbaabbabb", "abbabbabaaaabaaababaabaaabbababbbb", "bbbbbbbababababbbaaaaaaabaabbabaab", "baababaabababbbaaaabbaaaaababbbbab", "baabbaaaabbabbabaabaabaaabbbaababb", "baaaaaaaabbbabbababbbbabbababaaaab", "bbbbaabaaaabaababbaaababbaaaabbbaa", "abbababbbaababbbbbbababbaaabbababa", "ababababbaaabaabbaabbbababbaaabbab", "babbbbabbaabbbbababbbabbbaaaaaaabb", "aabbbaaaaabbaabaaabbbaaabababaabba", "ababaabbbbbaabababababaaaabbbabbaa", "bbbaabaaabbbbaababbbbbabbbbaaabbba"}

{"k", "K", "H", "f", "r", "G", "g", "t", "y", "J", "R", "s", "B", "d", "o", "F", "a", "L", "z", "i", "v", "x", "p", "e", "Q", "E", "w", "n", "C", "P", "M", "q", "c", "l", "A", "h", "u", "j", "b", "D", "m", "N", "I", "O"}

{"bbbababababbbaaabbabaaaabaaaaabbaa", "ababbaabbabbabbaaaaaabaaaaaaaaabbb", "abbaababababbbbaababbbbabbababbaaa", "ababbabbababaaaabaaaabababaababbab", "aaaabbaabbbaaaaaabbabbababbbbabaab", "abbaaaabababababbbaabababbbbabbaaa", "babaabbbaabaaabababababbbbbbabbbab", "aaabaabaaabbabaaaaaabbaababaaababb", "abbbbbaababbabaabbabbaaabbababbbba", "babbababaaaaaaababbbbbaabbbababbab", "bbabaaaaaaaaaaabbbaaabbbaabbaabaab", "bbabababbaaabababbbabbaaaababbabba", "abbbbabbbbabbbbabababaabaaaabababa", "abbbbbabbababbabbabbbabbbbaaaaabaa", "abbaaababbababbaabbaababbaaaabbbaa", "aababaababbabaabaabaabaabaababaaab", "bbabbabaabbaaabbbaaabbbbabababbaba", "aaabbabbbabbaaaabbbbbbbbbaabbaabbb", "aabaaaaaabaaabaabaababaabbabaaaaab", "bababaaabbbbaaabababbbbbbabbbaabaa", "bbabbbbbbbbaaaaabaaabbaabaabbabaab", "baaabababbbabaabbaabaabababaaabbbb", "baabaabaaaaaabaaaababbbaabbbbabbbb", "aababaababbaaaabbabababababaababba", "ababbaabbabbaababaabbbbaaaabbbbaab", "baaabaaaaababaabaaabaababbaaaabbaa", "baabababbabaababbbbbbabbbabbbaabbb", "baaabaabbbbbbbabaabaaababbbbbbabab", "bababbbaaabbaabbabaabbbababaabbbba", "bbabbbababbababbababaaaaaabaaabbaa", "aabbaaaabbbbbbabbbbabaabbbbbbaabba", "baabaabababbaaabaaabbabbbbabbbbabb", "abbbaaabbaaaabbbbbbbbaabababaaaabb", "aaaabbaaabbbabbbababbbabbaabbbbaaa", "abbaaaabbabbbbaabaabababbaababbaba", "aaababababaabaaaaaaaaabababbaabbab", "bbaabbbaabaaabbbaababbaaabbaababba", "abaaaabbabbbaaabaaaaaabbbbaaaabaab", "aabbabbbaababbbaabbaaabbbaaaaaaaba", "aabbbabbbbaabbbbabaabbaaaabaababba", "baaaaaaababbabbabababaabaaaaabbbbb", "baaaabaaabaaaaaababbabbaabaaabbaab", "aaabaaabbbababaabbabbaababaaabaabb", "babaaabaaabbbbabbbbababbbabbabbaab"}

"R"

Returns: "H"
{"k", "t", "o", "D", "s", "e", "d", "p", "C", "g", "i", "x", "h", "q", "z", "m", "v", "j", "w", "r", "E", "l", "c", "u", "y", "A", "b", "a", "B", "n", "f"}

{"babababbbbabbbbabababbbabbbbbabbabbbaababbbaa", "bbbaaabbbbabbabbaabbbbabbbaaaabbabaabaaabbbaa", "baabbbaaababbaaaaaaababbabbabaaaabaabbabbbbaa", "baababababbbbbaabbbabaaabaaabbbaaabaaabbbbaaa", "abaaaaaaaaaaababbbaaabbabaaaaaabbaaaaabbaaaab", "abaaaabbbbbbbaababbaaabaabaababaabbbbaabbbbaa", "baaabaabbbbabbbbaababaaaaaaaabbabbbbababbaabb", "ababaabaabaaabbabbbaabbaabaaababaaaaabbababab", "bbbbaababaabbaaabaaababababaaaaabbabaaabbbabb", "aaabbabbbaaabbabbabbaabaaababbabbbaabaabbbbba", "baaababbbbaababaababbaabaababbaaaaababbbbabba", "bbaabbbbbabbbbbbbbabbbbabaaababbbaabaabaaabaa", "babbbabbbaaabaabaaabbbbbbabbaabbbabbabbbaaaaa", "aabbbbbababbbbaabaabababbaaabaaaababbbababaaa", "bbabaaaaaaaabbaaaaabbaabaabbbbabbabaabbaaabaa", "bbbaabababaabababbbaabbaaaabbbbaaababbbababaa", "bbaaaaaabababbababaaaabaaabbbbbbbbbabababbbab", "abbbaabbaaaababbbabaabaabaaabbababababaaaaabb", "baaabbbaaaabbbbaaabbabaabaaaabbabaabbbaabbbab", "abbaababaaaabaabbbbbabbaaabbbbbababbabbbaabab", "babaaaaaaabbbababbaaabaaaabbabbbaaabbaababbba", "baaaaaaabbbbbabaababababbababaaababbaaaabbbab", "babbbaabaababbbaaaabababbaaaababaabbabababbab", "aabaabbbabbbbaaaaabbabaababbabbaabaabbababaab", "aaaaaabbabaababbbbaabbabaababbbabbbababbaaaab", "baaaaaaaaaabbaaaabbbaabbabaaaabbaaabbbabbaabb", "babaaaaabbababaaaabaaaabaababbaabbbbabaaaaabb", "aabaabaaaabaababababbaabbaaabbaabaabaaaaabaab", "abbaaababaabbbbabbaaaabaabbaababbbaaabbbbabab", "baaaaaabbbabbabbbbbbababbbabaabaaabbbababbabb", "babbbaaabbaabbabaabbabaabbbaabbbabbbaaababaab"}

{"A", "s", "z", "j", "k", "i", "d", "m", "f", "g", "b", "D", "v", "y", "c", "B", "r", "h", "x", "a", "e", "q", "E", "p", "C", "o", "w", "l", "u", "n", "t"}

{"aaaabbabbbbaabbabbbbabbabbabbbbbbaaabaaabbbbb", "bbabbbbbaaabaababbbbababbaaaaababbababbaabaab", "bbbaabaaabaabbbbabbbbabaabbabbaabaabbabaaaabb", "bbabbaabaabbababbbababaabaabaaababbbaabbaaaaa", "abbabbaabbbabaaaababbaabaaababbbaabbbaaaababb", "bbbababaaaabbbbbabaabbabbaaaaaabbaaabaaaabbba", "bbabaaabbababbbababbbaabbaabbbaaaabbabaaaaabb", "babaabbabbbbabaabaaaabbaabaababaaaababaaabaab", "aaababababbbaaabbaabbbabbbabbaabbabbaabbbbabb", "baaabbabbaabaaabaaaaababaabaabaabbbbbbaaaaaba", "abbaabbabbbbaabbbbabaaabaaababbaabbbbbabaaaba", "aabbbababaaabbbaababbbbbaabaaaaabbbaaaaabbaaa", "bbabababaaaabbbabbbbabaaaababbbbbabaaaaaababa", "babaaaaababbabbbbaabbbababbbbaaaaaaabaabaabba", "bbbbabbaabaabbbaaabbaaabbaababaaabbbaabaaaaaa", "baaabababbabbbbaaabbaaabaaabbbaabbbabbabbbbaa", "abaaabbbbabaabaababaaabbbaababaababababaaaaaa", "aaaabbabaaaabbabababaaaababbbabbbbaababbbbaab", "aabbbbaabbbaaabbbbaabbbabbaaaaababbbaabbbbaba", "aabaabbbaabbbabbaabaabbaaaaaababbababbaaabbba", "abbbaaaabaabbaabbababbbbbaaaabbabaabbabbbaaba", "abbaabbaabbaabbbbbbbbabbbabbaaabbaababbabbaab", "aabaaabbbbbabbbaabbabbabaabaabbabbbabbaabaaab", "abbaabaabbaaabbbaaabaaaaabbaaaabbbbaabaabbaaa", "baabbbaabbababababbbababbbbaaabbabaaabbababbb", "aaabaabaaabbabbbbaabbabbbbaabbbaaaaaabbbabbaa", "abbbbaabbbaabbbbbabaaabaaaaaabaabbbbaaabaabaa", "abbbbabbabbababaabbaaaaabbbaababbababbaabaaab", "bababbabaaabaabbaabbbabaaaabbababbbabbbbbaaab", "bbaaabbbbabaaabbbbbabbbaabbaabababaaababbabbb", "aaaabbabbaaaaababbbbabaababbabbaabbbbbabaabbb"}

"E"

Returns: "y"
{"d", "j", "b", "k", "l", "w", "u", "z", "t", "c", "m", "f", "g", "s", "h", "e", "y", "A", "v", "o", "q", "n", "a", "i", "p", "r", "x"}

{"bbaabaaabaaaabaabbbababaa", "bbbbbabaabbaaabaaaaabbaab", "aaaaaabaabaaaabaabbbaabba", "abaabbabaaabbbbabaabaabbb", "babbaabbabbabaabbbaaaabbb", "bbbbbbbaaababbbbbbbabbbba", "bbbbbbabaaabaabbaaaabbabb", "baabbabbbaaabbbabaaabaaba", "ababaababbababbabbbaababb", "aabbbbabaaabbaabbbbbbabaa", "aaabaaabbbaabbbabbaabaaab", "bbabbaaaabaabbbaaaabaabba", "bbabbbbbbabaabbababaabbbb", "baababbabbabbabbaaaabbabb", "bbaabaabababbbbbabbbbabab", "bbabababaabaaabababbabbbb", "babbaabaabbbbbaaaaaababaa", "aaabbaabbbaaababababbabab", "babbabbbbababbbbbbbaaabbb", "baabbabaabbbaaabbbabbbabb", "babbbabbbbbbababbaaaaabba", "bbabbaabababbbabababaaaab", "babbbbaaaaabbbabbabbaabab", "abababaaaaaabbbaabaabbbbb", "bbaabbbbababaabaababbaabb", "bbabbbbababbbaaaaabbbabba", "aaaabaabababbbbbbbabaaabb"}

{"v", "p", "t", "d", "a", "f", "n", "h", "w", "b", "z", "A", "o", "x", "r", "i", "q", "c", "u", "k", "j", "y", "e", "s", "g", "m", "l"}

{"aaabbbbaabaabaaaababaaaab", "abbabbbbaabbbbaaaaaaabbab", "baaabbbaabbabbaabbaabaaaa", "baaaababaaaaabbbabbbabbbb", "abbaaabaaaabbaaabababbaab", "baabbbabaaabbbbaabaabbbaa", "aabbbabbbbbbaaababaaabaab", "abbabbaabbbaabaaabababbbb", "babaaaaaabbbbabbbbabbbbbb", "bababaaaabbbabaaabbaaabbb", "bbaaababbaaaaababbbbbbaab", "abaaabbabbbaabaabbabbbaaa", "babbbaabbbbaaabbbaaababbb", "abbabaaaaaaaaabbabaabbaba", "babababaabaabbaabaabaabaa", "babbabbaaaaabbabbbababbbb", "aaaaaabaababbbababbaaaaba", "bbbaababbbbaaaabababababa", "aaaabaabaaaaaabbbabbabbbb", "aabababbbabaabaabbbaaabaa", "bbaabaaabbbbaaabababaabaa", "aabaaaaabaabaaaabbaaababb", "babbbbbaabaababbbababaaaa", "aabbaababaabbaaaabbaababb", "aaaaabbbbbaabaabbababaaab", "ababababbbaaaaaabbabbbbab", "abbabaabbabaaabbbbaababbb"}

"t"

Returns: "y"
{"h", "i", "e", "b", "p", "f", "c", "u", "m", "y", "g", "r", "z", "t", "q", "n", "k", "A", "a", "w", "o", "d", "v", "j", "x", "s", "l"}

{"aabaababbababaabaabaaaababaabbbababbaaaba", "abbabbaabbababbbbaababaaababaaabbbababbaa", "aaaaabaaaababbbbbbbaabaaabbbbabbababbbabb", "aabababbbbbaabbaaabaabbbaababaaababbbbbba", "bbbabbaaaabaabbbbbbaabbbbbbbbabbaaabbbaab", "abbbbbaabbbbbbbababbabbbbbaababbaaabaabab", "abbaaaabbbaaaabaaaababbaaababbaababbbabbb", "bbabbbbbabbbabbbbbaaaababbbaaabaaaabaabab", "bbaabbbaaaabbbaaaaabaabbbabbabbbbbbaabbba", "bbbbaabaaababbbabbaabbbbbbbbbbbbbbaaaaabb", "bbabbaabbaabbaabbbaabbbaaaabbbbbabbbaabba", "bbabaabbaababbbbabbbabbbbbababbaaabbaaaab", "bbbbbbbaabbababaaaaaababbbaaaaaaaabbbbabb", "baabbbaaaababababbaaaabbbababbbbbbabbaaba", "aaabbbbababbbaabaabaabaaaabbaabababaaaabb", "bbbabaabbabbabbbaabbaaabbbbabaaaabbbbbbba", "bbababbbbbbbbabaaababaabbbbaaabbaabaabbbb", "aabaaabbababbbababbbbbbaabaababbabbbbaabb", "babaaaabbaaabaaabbbaaaaaaababbababaaaaabb", "abbbababbbaaabbbaabaaaaaaabbaaabaababbbab", "babbababababbbaaaabaabbaaaabbbbaaabbbabbb", "bababbaaaaabaaaabbbbbbbaababbbabbabaabbba", "babaababbaaabbbbbbbaabbabbaabbbbaabaaabaa", "baabbbaaaabbbabbbaaaabbbbabaabaabbaaababb", "bbabbaaababbbbbbaaaababaaaabbbaabbabaaaba", "bbbabbbbbabbbabaaababbbabaababaababbaabbb", "abbabbbbaababbbababbbaabbbabbabababaaabba"}

{"n", "y", "e", "l", "b", "h", "p", "s", "j", "f", "a", "m", "q", "r", "u", "k", "v", "t", "A", "x", "z", "w", "i", "o", "d", "g", "c"}

{"bbbabbaaaabbaabbbbaabaabbaaababbbabbabaab", "bbabbabaabababbaaaabaababbbaababbbaabaaaa", "bbaabaababbabaabbabbbbabaabbbbbaabbababab", "babbaaaabbbbaabbbabbaabbbbababbbbbbbbaabb", "aabababbbaaaabbbaaababbbabaaaaabbabaabaab", "aabbababaaabbbbbbabbbbbbabbbbbabbbaaaabab", "aaabaabbbabbbabababaababababababaaabbaaaa", "bbaaabaaaaaaabbaababbabbaabbbaabbbabbbbaa", "bbbbaaaabbaaaaababaaabbabbaabaaaaaabbaaaa", "baabaaababaaaaababbaabaababbaaaabbbabbabb", "aabbbbaaabaaabaabaaabbababaaaaaabbabaabbb", "abbbbaabbabbbbbaaaaaaaaababbabaababaabbaa", "baababbbaaababaaabababbbabbbabbabaabbbabb", "bbbabbbaabbbbabaaaabbaaabbbaabbaaabbaabaa", "babbbaaabbaaabbaaabaaabbabbaabaaaaaaaabba", "aabbbaabababbaaaaababbbabbaababbbabbbabaa", "abaaabbbbaaaaaaaaabbbbaaaaabbabbaabbbbaab", "bbbaaabaaaaaabbbababbbbbbbbaabbbaabbaabba", "aabbbaaabaabbaabaaabbbabbbaaababaabaabbaa", "aababbbbaaababaaaabaaaaabaaaababbabbbbaba", "babababbaaabbaaaaaaaababaabbbbaababababab", "bababababbaabaababaaaaabaababbbabbabaabaa", "aaabaababbaabaabababbabbbbaaaaaababaabbaa", "baaaababaaaabaabaaaababbbbababbabbaabbbbb", "bbbbbaaaabbaabaabbababbbbaabababbbbaabbba", "babbbbbaababbaabaabbaaabababbbbbaabbbbaaa", "aaababaabbbbbbbbaaabbabbbaababbbbaaabaaab"}

"c"

Returns: "z"
{"b", "u", "o", "f", "t", "j", "a", "i", "l", "p", "w", "r", "C", "v", "B", "m", "g", "h", "z", "d", "D", "E", "n", "y", "c", "A", "F", "e", "q", "x", "s", "k"}

{"bbaaaabaaaababbaaababaabbbbbbbaabbabbbababbbaa", "aaaabaabbbaaabbaaaaabbbaababbbbaaabaaaaaaaaaab", "aabbababbabbbaaaaabbbabbabababbabbbabababaabba", "bbbbbbbbabbbaabbbbbbbabbbbbbaaabbbaaaabaaaabaa", "babbaabbbaaaabaaababaabaababababbababbbbbbbaab", "abbaabababaabbaaabbabbbbaaaaabbbbaaaabaaababab", "baaabaabbaaabbabbaaaaabbbbabbbaaabaabbabbaabab", "bbbaabbaaaabbbaaaaaaaabbbabaabbbbabaabaabbbaba", "baabaababbbabbbbabbbaabaaabaabbaabbabbbbbabaaa", "babbbaaaababaabbaaaabbabbabbbbbabbbbbabaabaaab", "abaababbabbbbbbbaabbaaaababaaabbabbbbbbababaab", "aaabbbbababbbbbbbabaabbbbbbbabaaaaababbbaaabaa", "baabbaaaaaaabbaaaabbaaababbbbbbbbbabbbbaabbbaa", "babbaababbbabbbbaaaababababbbbbbaaabbaaaababba", "bababbabbaabaabaabaabbaaabbabaabaabbbbaabaabbb", "bbabaaaabaaaaaaababaabbabaababaaabbbbbaabbbabb", "bbbaaaaabbbaababaabaaaaaaababbbbaaababaaaabbba", "bbabbaabbbababbabbbabbbbaaaabaabaabbbbaabababb", "aaababbbbbaababaabbababbaabbaabbabbbabaababaab", "baaabaaabaabbbbbbbaabbabbabbaabbbbaaabababbbab", "aababbaababbabbaabbbbaababbabbabbbaaabababbaaa", "abbbbbbabbabbabbbbaababaaabbbaabaabbbaaaaaabbb", "baabaaaabbbbbbbabbbbbabbaaabaabbaabbaaabaabaab", "bbbbaabbabbaaabbaaabbabaaabbabaabbbabbbaaaabab", "ababbabbabbaaaabbbaabbbabbbabaaaabaaabbaaababa", "baababbbabaababaaaaabbbabaabaaababaaaaababbbbb", "aaaabaaaabbbbbbaabaaabbbbbbaaabaaabaaabbabbaaa", "baabaaaaaaabbbbbaababbbababbbabbababbaaaaabbab", "abbababbbabbaaaabaabbbbaabbbabbbaababbbaaaaabb", "abaabbaabababbabbbabaabbbabbbababaaababbaabbaa", "bbbbbaabbbabaaabbbabbaaabbbbbabbaabbbbaaababba", "babbabaaabbaaabbaaabbbabbaabbabbbababbbbbaabaa"}

{"E", "d", "v", "y", "q", "z", "g", "B", "c", "C", "b", "A", "w", "o", "r", "u", "x", "F", "j", "D", "n", "h", "i", "s", "p", "m", "a", "k", "e", "t", "l", "f"}

{"babaaaabaaaaabbabaabbaabbbabbbbaabaababaababaa", "baaabbbbbabbbabbbaabaaabbbbaaabbbabbbaabbbbbab", "bbbbbaababababaabaabababaababbbaabaabbabaabbbb", "abbbbbaabaaaaaabbabaababbbaaaaaaaabbabababbbba", "babbaaabbabbbbbaabaaaabbbbabaaababaaabbabababa", "aaaabbabbaabbaaabbbbbbabbabababbaaabbaaaabbaab", "aabbaabbababbbbaabbbaabbaabbaababbabbbbaabbaaa", "abbbbaaaabababaabaabbbababbbababaaabbabaababab", "aaabaabbbabbbbbbbaabbaabbababbbabaabbaaaabbbba", "bababaaaabbbabaaabbabbbbbabbbbaababbbbababbbab", "bbaabaabbbaaaababaaaabbbababbbbaababbbbbbababb", "aaabbbaabbbabbaabbbabaababbabbaaababbabbaababb", "aabaaaaaaaabbaaabbabbbaabbbbabbbbbaaaabbbbaaba", "baaaaabbaaaaaababbbabaabbaabaaababbaaaababaaba", "aabbbaaababbbabbaaabbbaaaabbabbbbbabaaabaabaaa", "aababababbbaabababaabbbbabbbababaabbabbbabaaaa", "babbaaabbabbaaabbaaaabbabbabbaaaabaababbaaaaab", "bbabbaaabaabbabbababbbbaaababbbbabaabababaabba", "aaaabbaaaabbbbabbabababbaabaabbbaaabbaabababbb", "babbbbbbbaaabbbaabaababaaabbababbbabbaaaaabaab", "aaaabbbbbababbabbbbbaabbbbbbababaaababaabaabbb", "bbababbbabababbbbbababbabbaabababaabbabaaababa", "abaabbbaabbbbbbbaabbbbabbabaabbabbaaaabaabaaaa", "abaabbbbbbaabaabbaababbababbbabbabbababbbbbbba", "aaabbabbbbbbabababaaabbabbbaaaaaaabababaabbbbb", "aababaabababaababbabaaababbbbaabaaaaaaaabaaaba", "bbbaabaabbbaabbbabbbbaaaaabbaaabbabbaaaababaab", "bbbaaaabbbabaabaaaabababbbbbaababaaaaabaaaaabb", "aabbaabbbbbaababaaaaaabababaaabbbbabbbbbabbabb", "baaabaabaaabbbbbbbabbbaabababbbbbabababbaaaaba", "abbabbabbababaaabbbaaabaabbbababbbababaaababbb", "baabaaabbbaaabaabaaaabbabbbaabaababaababbbbaba"}

"k"

Returns: "E"
{"e", "d", "c", "a", "b", "h", "g", "j", "k", "f", "i"}

{"aaaabababaabbaaaababbbaabbabbaba", "bbaaaabbaabbbbaaabbaaabbabbbbbbb", "bbaabbbbbaaabbaaabaabbbbbabaabba", "babbaabbbbaabbbabaaabaabaabaaaaa", "aaababbbaababbaaabbaaababababbbb", "abaaaaaabaababbabbbabbbaabbbabba", "ababbababbababbaababbaabababbbbb", "abbbaababbbbbbabbababaaaabbbabba", "babababbaabbbabababbbbbaaabbabaa", "aaababaabbaaabbaabbabbbaabaaabba", "baabbaaaaababbbabbaababbbaabbbab"}

{"f", "g", "c", "j", "b", "e", "i", "a", "d", "h", "k"}

{"bbaababaaabbbabbaaaaabbbaaababba", "ababbbbaaaabaabaaaaaaaabbaaaaaaa", "bbabbabababababababbabbbaaabaaaa", "aaababaaabbababaaabbbabbbaaabbba", "aabbaabaaaabbabaaabbbaaababbbaab", "ababbabaabbbbbbbaaabaaaabbabbaba", "aaaaaabbbbbaababbaaaabaaaabbbaab", "abaabaaabbbabaaaaababbbbaaabaaab", "abababaabaaaabbaabbabbbabaaaabaa", "bbbaaabbaabaabbabaaaabbbaabaabab", "babaaaaabaababbaaabaaabbbaabbabb"}

"k"

Returns: "b"
{"B", "A", "d", "y", "e", "u", "J", "f", "r", "a", "b", "g", "x", "I", "D", "c", "t", "i", "h", "G", "K", "l", "F", "n", "m", "s", "H", "k", "p", "v", "q", "o", "j", "C", "w", "z", "E"}

{"aaabbbbaaaaabbbbbaabababb", "aaaabbbaabbbabbbbabbbabbb", "bbbabababbaaaababbbababba", "ababbaabaaaaaababaaaabbab", "bbabbbaaaabbabbabbaaaaaaa", "babbbbabaabbbbbbaabbbabab", "aabbababaaabaaabbaaaaabaa", "aaaabaabbaabbbaabaaabaabb", "aabbbaaabbaabbbabbbbaabab", "aaabbbababbbbaaabbaaaabbb", "baabbbbaabbaaabbbbbbaabab", "aaaabbabbababaaaaabbbaaaa", "bbbababaababaaaaaaabbbbbb", "bbbabbbabbbababaabaabbbaa", "bbaaaaaaaabaabaaaabababab", "aaaabbaabbbabaabaabaabaab", "abbbbaaaabbaaaaaabbbaaabb", "bbababbbaabbbaabbbabaaaaa", "baaaababbabaaababbbbbaabb", "aabbaabbabaabaaaabaaababa", "babbbaaaabbbbaaaaaabbbaab", "babbabababababbbbbaababba", "abbbbbabbbbabababababaaaa", "aabbabbaabaaaabbbaabaaaab", "aabaaababbaaaababbabaaaba", "babaaabbaabbbaababaaabbab", "bbabbaaabaaaabbaabbbaabab", "bbbbababaaaaaabbabaababbb", "aaaabaaaababbabbaabbababa", "baaaababbaaaaaaababababba", "aababbaaaaaaaaabbababaaba", "abababaaababbbababbaabbab", "babbaabaaabaaaaaabbbaaaba", "baaabbbabbabaabaabaabbbab", "baabbaaaababbaabbbbaaabaa", "bbababbbbaababbbabababbaa", "baabbbabbbaabaaababbaaaab"}

{"f", "k", "E", "t", "n", "p", "s", "F", "w", "u", "a", "x", "e", "r", "G", "j", "v", "B", "o", "y", "A", "l", "b", "H", "D", "h", "g", "m", "J", "i", "q", "c", "z", "d", "K", "I", "C"}

{"abbaaabbababbbbbbbbbbabbb", "bbbaabaababbbbbabababbbab", "baaaabbababbbbbaaabababba", "bababbababbbbbaaaabbbaaab", "ababbabababababaababbbaba", "babaaabbbbaabbbababaabbba", "baabaaaabaababaabababbaab", "aabaabaabbbbaabaaaabaaabb", "babaabaabbbabaaaabababbaa", "bbaaaaabababbbabababbaaba", "aabbbababababaaabaabbabaa", "babaabaaaaabbbaabababaaba", "aaabbaaaaabbbaabbaabbbbbb", "baaaaababbbbabaabbaababbb", "babbabaabbaaaaaaaaaabbaaa", "bbbabbbbabaababaabbababbb", "ababaabbaabbaababaaabaaab", "babbabbabbbabbabbbaaaaaba", "bbbaabaaabaabaabbbbabbbbb", "bbaaaabaaaabaaababaabbaab", "baabababbbbaabaabaaabbaab", "bbbabbaabbbbabaaabaabbaba", "baabbbaabbbbabbababaaaabb", "bababbbbaaaababaaababaaaa", "aaababaabbabbbaaabbababab", "bbbabaaabbaababbbaaaabbbb", "bbbabbababbbaaaabbaabbbaa", "abaabaaababbaaabaababbaba", "abbaaaaaabaababaaabbbaaab", "aaaaabbbbabbbaaaaabaababb", "ababbaaababbaabbbbbbbabab", "aababbbbbbabbabbabbbbbbbb", "ababaabbabaaabaabbbaaabba", "abbabbbbaabaabbbbbabababa", "baaaaaaabaabbbbbabaabbbba", "aaababbbbabaabbabbbbbbabb", "abababbaaabaabbbaabbbaaba"}

"j"

Returns: "n"
{"l", "s", "I", "j", "y", "h", "z", "C", "k", "f", "r", "m", "t", "n", "a", "H", "w", "b", "F", "d", "B", "E", "u", "g", "q", "G", "o", "c", "e", "v", "A", "x", "i", "p", "D", "J"}

{"bbabbababababaabbbb", "bbbabbabbabbaaaaaaa", "aaaaaababbaaabbbbbb", "babaaababaaabaaabba", "baababaaaaabaabbbba", "abbaabbbbbabaabbbbb", "babbbabaabaabababaa", "babbaabababaabbabba", "bbabbabbabbbbbabbbb", "babbbabbbabbbbbaabb", "aaabbabbbaabbbaaaaa", "baaababaaaabaababaa", "aaaababaabbaaaaaaab", "aabababbbbbbababaab", "abbbbabbbbaabbaaaab", "baaaaaabbbbbbbbbbaa", "baabbbbbbbabababaab", "aaaabbabaaaababaaba", "ababbbbbababaababba", "bbaaaabbabababbabaa", "abaabaabaabaaaaabba", "abbbbbbabbbbabbbbbb", "baabaababbbaabbbbba", "aabbbbbbbaabababaab", "babbbbbaabbaaababab", "aababaabbababbaabba", "babbbabaabbabbbabaa", "bababaabbbaaabbbaba", "abbababbbaababbabbb", "bbaabbbabbbbaabbaba", "baabbbabaababababab", "bababbbaaabbabbbabb", "aabbbabbabbbbaabbab", "aabababbababaaaabbb", "aabaabbbbabbabbbbbb", "baababbabaaabbabbbb"}

{"E", "m", "e", "B", "G", "k", "v", "c", "C", "d", "b", "t", "n", "g", "x", "H", "q", "h", "r", "J", "s", "f", "i", "u", "j", "y", "D", "o", "p", "z", "w", "F", "I", "l", "A", "a"}

{"babbabaaababbbbabaa", "aabbabbaabbabbbbabb", "bbbaabaabbaabbabaab", "abaaaabbbbaabbaabaa", "abbbabbaaababbbbbab", "abaaaabbbaabbababba", "bbbbbbababbaabbaaaa", "aabaaaabbaaabbabaab", "ababaaabbbabbbabbbb", "bbaabbbbabababbbbab", "bbbabbabbabbabbabab", "aaaaaaabbabbbbbbaab", "aabaaaabaaabbaabaab", "aabbbaaabbabaababbb", "abaabbbbaaaaaaababa", "aabbababaaabbbbaabb", "bababaaabaaabbaabbb", "abaaaabaaaabaaaaaab", "aababaabbbaaabbaaba", "ababaabbababbbbbbaa", "aaabaabbababaababbb", "bbababbaaabbababbbb", "abbabaabbbabbbabaaa", "aabababaabbbaabbaba", "babbbbbbabababbbbba", "bbbababaabaaabbbabb", "baaabaabababbbbaaaa", "bbbbababbabaababaaa", "bbaabaaabbbabaabbbb", "abaabaaaabbaaabbbba", "aaaaaaabbaaabaaaaaa", "babbbbbabbabaaabbaa", "abbababbbabbabbaaba", "bbabbbbbabbaabbbbab", "aabaaaabbaaaabaabba", "babbbabababaabbabaa"}

"v"

Returns: "u"
{"a", "b", "d", "e", "c", "f"}

{"bbabababbbbaaabbbabbbabbaabbbaaa", "aaabaababbababbbbaaabaababbabaaa", "aabababbbbaaababababaaaaaaabbbba", "bbbbaabaaabaabbbbabbabbabaabbbab", "abbabaabbbbbabaabbbaabbabaaaabba", "aaabbabbbaaabaaaabbabaaaaaaaabba"}

{"a", "c", "f", "d", "e", "b"}

{"baabbabbabbababbbabbababbaaabbab", "abaabbbbaabbababaababaabbabbbaaa", "abbbbbbaaababaabbaaabaabbaabbbbb", "babbaababababbbbabaaaaababaababa", "ababbababaababaabaaababaaaaaabaa", "bbbabaaaabbbabbbaabaababababbaba"}

"f"

Returns: "f"
{"u", "n", "y", "s", "l", "f", "e", "F", "a", "i", "E", "h", "b", "B", "p", "A", "k", "D", "j", "c", "t", "z", "x", "C", "v", "w", "o", "g", "q", "m", "d", "r"}

{"bbaaab", "aaaaab", "baabbb", "aabbbb", "baaaaa", "bbabaa", "babaaa", "abbbab", "abbbaa", "aababb", "aaabbb", "ababba", "aabaaa", "aabaab", "bbbbbb", "babaab", "baabaa", "baabab", "baaaba", "bbbbbb", "bbabbb", "bbbaaa", "baaaab", "aaabbb", "abbaaa", "baaabb", "bbbbaa", "aaabba", "baabab", "bababa", "aabbaa", "bbaabb"}

{"m", "d", "D", "c", "F", "e", "A", "g", "z", "o", "u", "p", "i", "n", "C", "s", "r", "j", "t", "x", "f", "q", "E", "B", "a", "k", "b", "y", "w", "v", "l", "h"}

{"ababab", "bbbaba", "babaaa", "aabbaa", "bbabba", "abbbaa", "bababa", "abbbab", "baaabb", "babbaa", "bbabbb", "bbaabb", "aabbab", "abbaab", "baabbb", "aaaaab", "abaaab", "aabbbb", "bbabaa", "bbabbb", "abaaaa", "abbaaa", "bbaaba", "aaabbb", "abbbab", "bababa", "abaaab", "ababbb", "baabbb", "aabbab", "ababaa", "aaaaba"}

"E"

Returns: "j"
{"g", "x", "r", "y", "t", "l", "m", "d", "u", "n", "h", "e", "s", "v", "a", "i", "k", "p", "b", "z", "f", "j", "c", "w", "q", "o"}

{"baabaabaaabbaaab", "aaabbbbbbabaaaaa", "aaabbbaabbbbaabb", "aaabaabbabbabbbb", "babbbbabaaabbbbb", "aaaaababababaaaa", "baaaaabbbbbbbbaa", "babbbaaabbbbbbab", "aabbbabbaaababaa", "bbabababbbbabbbb", "ababbaababaaabab", "abbbbbbbaaaababb", "baaaaaabbabbabab", "baaaaabbaaabbbab", "baaaababbbababab", "abaabaaabbaabaab", "ababaabbaabaabbb", "abbbbbabbaaaaaab", "aabaaabababbbbaa", "bbaabbaaaaababba", "bbaababaaaaaabab", "baaabbbbaabaaabb", "bbbbbbbaabbbaaab", "ababaaaabbabaabb", "aabbbabbbbbababb", "bbabaabbbaababbb"}

{"b", "t", "u", "i", "d", "o", "e", "f", "y", "q", "l", "a", "s", "c", "x", "n", "k", "g", "w", "h", "z", "p", "m", "v", "j", "r"}

{"aababaaaabaaabab", "abbaabaaaabbbbaa", "bbababaaabbbbbbb", "abbbaabbbabbbabb", "babbbbbabbbaaaab", "baaaaababaaaabab", "abaaabaabbaaabab", "abbabaaaaaaabbbb", "aabababaaaaababa", "bbbaaababaabbbaa", "babbabaaaabaaaab", "abbaaabbbbaabbbb", "abaababaabbbabab", "aaabbbbababaabaa", "abbbbbbabbabbaaa", "abbababbbaabbaba", "bbabbaabaabbaaab", "abaabbabbaababab", "abbbaaaabbaabbab", "abaaaabaabbbabbb", "aababbaababbaabb", "ababbbabaaaaabbb", "aabaaabababbbbab", "abbaabbaabababab", "abbbabbbababbbbb", "bbaaababbabaabab"}

"d"

Returns: "w"
{"f", "M", "F", "K", "U", "b", "y", "m", "H", "J", "o", "I", "P", "Q", "w", "R", "p", "k", "O", "x", "a", "c", "D", "C", "l", "g", "T", "B", "s", "q", "n", "z", "i", "N", "u", "t", "e", "j", "E", "r", "S", "G", "A", "d", "h", "v", "L"}

{"bbbababbabbabbaabababab", "bababaaabbaabaabababbab", "bbbbbaaabaababbbaababaa", "baababbbbaabbaabaababbb", "abbaabbababaaabbbaabbba", "bbbbabbaabababbbaaabbbb", "aabaabbabbbabbabaaaaaaa", "aaaabbaabaabbbaabaabbaa", "abbabbababbbbaababbbabb", "aaabaaaaababaababaaaaaa", "aaaabbaaaabbbaabaaaaaab", "baaabbbbbaaaabaabababaa", "babaabaabaabababaabbbbb", "abbbbabbaaaabbbababbaba", "bbbaababababbabababbaab", "babababbabbabbbababbaba", "bbaabbbbaaabaaabaabbaaa", "bababaababbabababbabaaa", "babbbbaaaababaaaabababb", "bbaaaaaaaaabaaaababaaba", "bbaaaaaabbbbbbabbbaabba", "bbaaabbabbbbaaaaabbbaab", "bbaabaaaabbaabbbbbaaaaa", "ababbaaabbaaaaaaaaabaab", "aabbabbbababaaaabaabbab", "abbbbbbaaaaabbbbaabbabb", "bbaabbabbbbbaaaabbaaaab", "abaaaaabbabbbaaaabbbaba", "bbaabbabbaabbbabbababaa", "aababbbbabbbabaabaaabaa", "abbabaaabbbababbabbbabb", "ababbbabbbabaabababbbbb", "bbabababababababbbbabba", "babbbaaabaaabaaabbaabab", "baababaaaabbabaabababaa", "abbbabbabababababbbabbb", "baabaaaabbabaaaabbabbbb", "bbabbaabaabbababbaabbba", "baabaababbaababaaaaaaaa", "abbabbaababaabbbaabbbab", "aaaabaaabaabbabbaabbaaa", "abaaabbabaabaaaabababbb", "ababaaabbaabbbbbaaababa", "aabbbaaabbbbaaaaaabbbba", "abbababaabaabbbabababba", "aabbbaaaabababababaaaab", "abbbaababbaabaabababaaa"}

{"i", "P", "M", "v", "I", "q", "z", "A", "l", "w", "R", "t", "m", "f", "H", "r", "c", "G", "E", "Q", "D", "x", "p", "b", "B", "S", "F", "h", "O", "L", "u", "J", "K", "j", "T", "a", "n", "o", "C", "s", "y", "e", "g", "d", "N", "U", "k"}

{"bbaabbabaaaabbaaababbba", "ababbbbbbabaabbbabaabbb", "abbbbababbbbbaabababaaa", "bbaabaabbbbaababaaaaaab", "baaabbaabbabbababbabbbb", "ababbbbbabbabbbabbaaaaa", "baaabbbbbabbbbaaaabbabb", "babaaababbaaabaabbbaaab", "abbbababbbbbaaaaabbbaba", "ababaaabaaaaabaaabbabaa", "aabaabbbbaaaabaababbabb", "aabbaabaababbababbabbab", "babaaaababaabbaabbabaaa", "aaabaaaaabaaabbbbbaaabb", "aabaabbabbaaabbbaababab", "baaababaaabaabbbbaaabba", "bbbabaababbaaaababaabab", "aaaaabbabaababbaababaab", "babbaabbbbababbabbabbba", "aabaabbabbabaaabbbbbaab", "abbabbabbababaababbbbaa", "baabaaabbbbabbaabbababb", "abaaababbabbbbbbaaabbbb", "abbbababbbabaabbabaaaaa", "aaaaabbbabbbaabaaababab", "aabbbabbbbbbbaaabababba", "baabbbaabababbbbaaaaaba", "bababaaabbaaabbaabababb", "abbabbbbbbaababbbbbbaaa", "aabbbbaabbaabaaaaaabbbb", "aaaabbbabbbbabbbabbbabb", "bbbbbabbbbaaabbabaaaaba", "abbabbaabaabaaaabbbbbab", "aabbaabbabbabbaaaababab", "aaabbbbbbaabbaaababaaba", "baaaaababbabbaabbaaabaa", "ababbabababbaaabaabaaba", "abbbbbaaaaabaaaaaabaaab", "bbaaabbbbaaaaabbabbaabb", "abaabbbaaaabaaaabbbbbba", "aaaabababbbbaaaabababbb", "bbaaaaabbabaaabaaaababa", "babaabababababbbabbbaaa", "bbbabbabaaababaaaabaaab", "aabbbabbabbabaaaabaabba", "bbaaaabaabbabbbababbbaa", "abbababbbabaaabbabaaaba"}

"m"

Returns: "K"
{"b", "f", "g", "c", "d", "e", "a", "h"}

{"bababb", "abaaab", "aaaabb", "aaaabb", "bbabaa", "bbaaab", "babbab", "bbbbaa"}

{"f", "b", "a", "d", "h", "g", "e", "c"}

{"bbaabb", "abbbba", "baaaab", "bbbbaa", "baaaba", "aabbbb", "ababaa", "bbaabb"}

"g"

Returns: "g"
{"q", "b", "c", "n", "k", "m", "g", "p", "j", "r", "h", "f", "d", "i", "l", "o", "e", "a"}

{"baaaaabaabbaabaa", "bbabababbbbbbabb", "ababbabaaababbba", "bbbbbaababbbbaaa", "ababbbbbbabbabaa", "babbabaabaaaaaba", "baabbbaababaabab", "babaabbaabaaabaa", "abbaabbababaaaab", "bbaabbbaabaabaaa", "abbbbbbbbbbabaaa", "aabbababbbaababb", "aaaaaabbaaabbaab", "aabaababaabaabba", "aaaababbbbabbabb", "baabbaaabaabaaab", "aabaaabaaaaaaaab", "aabaaabbbababaaa"}

{"b", "j", "l", "q", "e", "d", "c", "f", "n", "p", "k", "r", "a", "o", "i", "m", "g", "h"}

{"bbabbababaabbabb", "baabaabbaabbabbb", "aababbbbabaabbbb", "babbaabbaabaaaba", "bbbaaabbaabbbbba", "bbaabbbaaaaabbbb", "ababaababbaabaaa", "bbaabbabbaaabbba", "bbbbbbbaaabbabab", "aabababababababa", "babaaaababbababa", "abbabbbbaaababab", "abbbaaabbaabbaba", "bbbbbbbbababbbba", "aabbbaabbbaababa", "bbababbbaabababa", "ababbababaaaaaba", "aaaaaaabbbbaabaa"}

"c"

Returns: "g"
{"d", "p", "J", "H", "h", "r", "M", "I", "b", "j", "v", "m", "N", "B", "A", "w", "x", "L", "l", "u", "a", "o", "g", "y", "z", "n", "f", "D", "c", "k", "i", "G", "e", "O", "F", "K", "t", "E", "C", "s", "q"}

{"abbabaabbbabaabbbaabaabababbaa", "abbaaaaaaabaababbbaabbaaabaaaa", "abbababbbababaaaabbaaaabbababa", "bbaabbbaabaaaaaaabababaabbbbaa", "aabbbabbaabababaabababaabbaabb", "aaaabaaaababaababbbbbaaabbbbbb", "bbabbbaababbaaabaaaabbbbbabbab", "abaaabbbbbabbaaababbbbaaabaaab", "aaaabbbabababbbbbbbbbaabbababb", "bbbabbbaabbaaababbbaababbbbaaa", "babbbaabbbbbaabbaabaaaabaababb", "aaabbbabbababbaabaabbaaaabbaab", "baaabbaababbbaaaaaaabaabbaaaba", "aaababbbabaabbbbbbbaaababaabaa", "abbabbabbbabbbaabbbbaaabbaaaaa", "baabbabbbbbbbbbaabaababbbaaaba", "bbabbabaaabaaabaabaaababbaabaa", "bbbbabaabbaabbabbbabaaabaaabbb", "bbbbbaaababaababbaabbbbababbaa", "abbaaabaaaababababbbaaaaababab", "aaaaaabaabbaabbbabaabbbaabaaab", "aababaaaaabbaaaababbaabbababbb", "ababaabbbaaaaaababbbbbabaaabab", "abaababaaabaaaaaabaaabaaabbbbb", "bbabbabbababaaabbabbbaabaaaaba", "ababaaaabbabaaabbabbabababaaaa", "abbbbaaaaaabbbbabababababbabbb", "aabbbaaaaabaababbbaabbabbabaab", "baabbbbaaaabaabbaababaaaaabbbb", "abbbbbbabaabbbaaababaababbbaba", "abaabbbaabaaaaaabaabbbbbbaabba", "aabaabababbabaaaaabaabaaababaa", "ababbbaabbbbaababbabbababaaaaa", "aabbababbbabbaabbaabbaabaabaab", "bbabbbbabbaaabbabbbbbbbbaababb", "baaaaababbbbbbbabaaabababbabab", "bbbaaababaaabbaabaaabbababbbba", "abbabbabbababbbbababbabaabaaba", "bbaabaaabbbaaabbaabbbaaababaab", "abaababaabbabaabaaabababbbaaab", "abbbbaabaaabababababaaaabbbbab"}

{"K", "C", "k", "b", "B", "D", "i", "u", "m", "f", "p", "x", "j", "G", "M", "n", "A", "e", "z", "J", "y", "h", "I", "r", "v", "a", "F", "o", "N", "d", "w", "L", "s", "O", "q", "H", "t", "l", "c", "E", "g"}

{"baabbaaaabbaababbbaababbabbbaa", "bbbbbbbaabaaabbbaabbbaaaabaaba", "bbbbbbabbaaaaabbaabbaaabaabbaa", "bbbbbbbaaabaaabaabaabbabaabbab", "aabbbaaababbabbaaaaabbabbbbbaa", "bbaaabbaaabbbbbabbbaabbabbabba", "aaaabaaabbaababbababbbbabaabbb", "bbbbbbabaabbbaaabaabbbbbbbbbba", "abaaababbaabaaabbbbababaaabaaa", "aaaabbaaaababaaaabbbabbabbbabb", "baaabaabaaababbaabaaaaababbaab", "abaaababbaaabbababbaaaabaabbab", "baaaabaabababaabaabbbbaaabbaaa", "bbababaaabaabaabaabbaabbbbaabb", "abbbbaabbabaababbabbbbaabbbbba", "bbbaabbbaaaabbababaababaabaaba", "bbabababbbaaaaaabbbbaaabbabbaa", "bbbbaaaaaabaaababbbabbbbbbbbbb", "aaaabaababbbbbabbaabbbbbbbaaba", "bbbababbabbaabaabbabaaabbbabab", "babaaabbabbaaaaabbaaaabaaababa", "baabbbaabbbaaabbaabaaabbbaaaab", "bababbbbabababbbbaaaaabbbbbaaa", "bbababbbbabbaaaabbbababbbbbbaa", "baaaabbabbaababaaaaabbbbbabbab", "ababababaabaababbbbbbbaaaaabba", "bbbbabbbbbaabbbabaabaabbbbbbba", "ababaabbbbabaabbaababbaabaabba", "ababaaababbbababaaabaaabaabbaa", "aabaaabaabbababbbbaaaaababbbaa", "abbbbbabbababaaaabbaaaaabababb", "aabaababaaabaaababaaababbabbaa", "abaabaabaababaaaaabaaaaababbbb", "baabaabbaaabbbaaaaababaabbabbb", "bbbbabaabbaaaabababbbabbaababb", "aabbbbaabbbaaaaaababbaabaababb", "abaaababaaababbaabbbaabaabbaaa", "babaababbaaaaabaaabababbbbabba", "abbaabbbaaaabaaaababbaaaabbbab", "bbaabaabaaaabbbabababaabaabaab", "abbbbabbaabbaabbbbaaaabbbbbbaa"}

"j"

Returns: "I"
{"e", "g", "i", "c", "h", "n", "q", "d", "p", "f", "k", "m", "o", "l", "b", "j", "a"}

{"abbababbbbabaaabbbb", "bbaaaaaaaaababaabab", "aaababababbbbababab", "babababbbbbaabbbbaa", "aaaaaaaabaaabaaabba", "bbbbbbbabbabaaabbaa", "aabbbabbaaaabbbbabb", "abaaaaaaaabbbababaa", "baaabaaabababababab", "babababaaaababaaabb", "bbbaababaaabbbbaabb", "aaabaabaabababbbbba", "abbabbbbaabbbbabbaa", "aabaaaabbbbbabaaaaa", "ababbbaaaaabbabbbab", "aabbabbaaabbbbbbbaa", "aabbbababbaababaabb"}

{"n", "k", "q", "d", "l", "a", "j", "g", "m", "p", "e", "i", "b", "f", "c", "o", "h"}

{"abbbabbbbabbabaaaab", "abbaabaabbbaaaabbab", "ababbbabaabbbbbabba", "bbaabaaaabbabbbabbb", "aaaabbaaabaabababaa", "abbabbaaabbaabaaaaa", "babaaababaaaababbaa", "bababbbbbaaaabbbbab", "abbbaaabaaabbaabaaa", "aaaaaabaaaabaaabaaa", "abbbbbbabaaaaabbbab", "bbbbbbbaaaaaaaaabab", "ababaabababababaaba", "abbaababbbbabbbbaba", "babbaaababbbbabaaab", "bbaabbabaabbaaababa", "aaaaabbbbabbaabbbab"}

"g"

Returns: "d"
{"i", "c", "m", "b", "f", "a", "h", "g", "j", "k", "e", "n", "l", "d", "o"}

{"aabababaabaabaababbababbbaaabbbaaaaabbabb", "aaababaababbbaabbaaaaaaaaaabbbaaaaabaaaaa", "bababbbaaaaaabbabbbbababbaababaabaababbba", "bbbabbbbaabaabaaabbbabababbaabbabbbabbabb", "aaaaaabababaaabaabaabbaaaaababaaababaaaaa", "baababaaaabbbabbbaaaabbabbbbaaaabbbbabaaa", "abbaabaababbaaaabaabababaabbbaaaaabbbabbb", "abbbbabaababaabbaabbaabbbaabababaabbbbbaa", "abbbabbaaaabaaababbbabaaaaaabbaaaabbabaaa", "aabaaaababababbbababbaaaababbbababbaababa", "ababbbaaaabaaabbbbaabbbaaababbabbbaabbaab", "baaaabbbbaaababbababbbbbabbabaababbabaaba", "ababbbabbabbbbbaaaaaabaaaaaaaaaababababaa", "bbababbabbbbabababaabbabbbaaabbabaabbbbab", "abababababaaaabbabbabbabbaaabbaaabaaaabbb"}

{"n", "b", "l", "a", "o", "k", "d", "g", "h", "j", "c", "m", "e", "f", "i"}

{"abaabaaaaaabbbabbbaaabaaaabaabbbaabbaaaab", "abaabaababbaaaabbbabaabaaaaabbbaabbbbbaaa", "abaabbbabbaaaabbbabbaabbababaaaabbbababaa", "abbabaabaabaabbbbbabbbbabbabababaabaabbab", "aabbaabbbaabbbababbbabbabbbbbaaabbbababaa", "abbaaaaababbaababaababaabaabbabbbbbbbabaa", "baaaaabbbbaaabaaaaaaaaaabaabbabbbbabbaaab", "abbbabaabaaabaaaaaaababbabbaabbbabaabbabb", "babaabbabbabbbbbbaababbaabbbbaabbabbbbaab", "aabaaaabbbabababbabbaabaabbbbbabaaababaaa", "abbabbbaababbbbaaaabbbaaababbbbaababaabaa", "babbabbaabbbbbabbbbbaababbaaababbbabbaaba", "aabaaaabbbbabaabababaaaaabababbaaabbabbbb", "abaabbbaabababbabbbaabbbbbabaaabaaabaabab", "bbbaaaabaabaabbbbbaababbbbaaaaaabbbbabaab"}

"m"

Returns: "m"
{"c", "l", "m", "f", "s", "n", "a", "p", "i", "o", "d", "r", "e", "h", "b", "q", "k", "g", "j"}

{"aabaabbaaaaabaabbbbaabaaaabbbbbbaabaabaaababbbabab", "bbababababbaaaabbbbbbabaaabaabbaabbbaaaaaaaaaababa", "babbabbbababbbaabaabbbbaababbaabbbbabbbbbbabbbbbbb", "babaabaaaaaabbabbaaabaabaaabaababaabbaaabbabbaabba", "abaaabbbaaabbbabaaaaabababaaaaabbabbbbaaabbaaaabab", "babababbbabbabbabaabbbabbbabbbaababbababbbbababbba", "abbaaababaabbbbbabaaabbaababbbbaabababbabbababbaba", "bbbbabbaaabaabaaabbaaaaaaaabbbababbbababbbbbaababb", "baaabbaaabaaabbababaababaabbbbabaababaabbabbbbbbbb", "abbaaaaabbaababaaaababbbbaaaabababbaaabbbbaaabaaaa", "babbabbbbbbbbbbbbbabbaabbbaabbbbabbbaaabbabbababbb", "bbaabbbbbaababaaabababbabaababbaaaababbabbbaaabbbb", "aababbbaabbbababbabababaabaabaaaaabbbbbabbbaabaaaa", "baababbabbaaaabbaababaababbbbbbbaabbbababababbbbaa", "baaaaabbabbaabaaaabbbbaabbabababaaababbabababbbbba", "abbaaabaabbaaaabbbbabbbbaabbababbbabaaaabbbaabbaab", "aaababbaabaabbabbbbaabaaabaabbabbaabababbaabaaaaab", "aaabaabbbababaaaabbbbbbabbbbbbbbabbaabaaaaaababbbb", "abaabbaaabababbaaaabbababbabbbabaaabaaabbbbaabbaaa"}

{"n", "a", "l", "h", "s", "i", "r", "d", "k", "b", "m", "q", "e", "o", "j", "c", "p", "g", "f"}

{"aabaaaaaababaaaaaabbaaaabbaababbbabababababababbbb", "bbbbabbabbbbbbbbbaaababbbbaaaaababbaabbaabaaaaaabb", "bbabbbbabbbabbababbaaabbbaaabbbaabbabbbbbabbbbabbb", "baaaaaaabaababbbabaabaabaabaaaaabbaaabaaabbaaabbba", "babbbababbbabbababbbbbabaaaabbbabababaaabbabbbbbab", "aaaabbabbaaabbbbabababbbabaaabaaababababbbabbbabab", "baaaabbabbbbbbbbaabaaaabaabaaababbaabbaabbabbabaaa", "abbaaaabbabaaababaaaabbbbabbaabbbbababbabaaaaabbaa", "babbabbababbbbabbbbbabbaababbbbaabbbbbabbbaaababaa", "abaabaababaabbbbbbbbabaaaaabababbaaaababbabababbba", "bbbaabbaaabbaabaababaaabaabbbbabbbbbababaaaaaaabbb", "bbbaabaabbbbaaabbaaaaabbbbaaaabbbbbabaabbbabbaabbb", "babbabbbbabbbbbabababbbabbbbbabbbbbaabbabbbabbabab", "baababbabbbbbaaaaabbabbababbbbbaaaaabaaababaaabbaa", "bbbaababaaabbaaaaaabaaabbaaababaaabbbabbabaaabbaab", "abbbabaaaabbabbaabbaaaaabaababbbaabbbaabbaaabbbbaa", "bbaaaababaabaaabbabbbabbbbbbbbaabababaababbabaaaba", "bbababbbaabbaababaaabbababbababaaaabbbbbbbbbbabaab", "ababbaaabbababbbaababbbbbaaaababaaaaaaaaabbaaabbab"}

"m"

Returns: "g"
{"h", "k", "u", "c", "P", "f", "J", "B", "s", "g", "j", "C", "S", "R", "Q", "E", "b", "v", "D", "o", "w", "O", "n", "t", "M", "H", "y", "q", "d", "F", "G", "I", "L", "a", "V", "x", "i", "e", "m", "l", "N", "z", "r", "T", "U", "A", "p", "K"}

{"abbabaabbbbbaabbaaaabbbabbbbbaaabaab", "baaabbabbbbbbbabbbabbaabbaaaaaaabbab", "bbabbaabaabaaaaaabbaaaaabbaabbbbbbba", "baabbbbaababbabbaabbabbabababbbbabab", "aaaabbbbbbbbbbbbaabaabbabbbbbbbaabba", "aabababbabaabbbaababbbaababbabaaaaaa", "ababbbbabbbababbbbaabaaabbaaababbabb", "aaaababbaabbbaaabaaaaababbaaaaabbbbb", "aaabbabbbbbbbbbbababaaaabbabbbbbbaba", "bbaaabaababbabaaaabaaaaaaaaaabbbaaab", "aabbabbbbaabbabaabbbbaababbaabbababb", "bbbabaaababbbaabbaaaaabbabbbbbbaabbb", "abbbabaabaaaaabbabbbaabbaabbabaaabba", "bbabbbbabaaaaababbbabaaaabaababaaabb", "abbbaaaabbbbbaaaabaaaabaabbbbabbbbaa", "babbaabbbabbbbbababababbbbbabbbabbab", "aabbbabbbbaaabbabbbbabbaababbababbba", "baaababababbbbbbbaabbababaaabaababbb", "ababbaabaaabbaabbbabaaabbbababbbbabb", "abaaabbbabbbbaabaababbabaaaaaabaaaab", "babbbbbbbababaaaabbbaaaaabaabaaabaaa", "aaababbbabaababababbbbbaabababbbaaba", "abaaabbabbaaabbaabaabaaabaaabbbbabaa", "bbababbbaabaabbabbbabbabbabaababbabb", "babaababababaaaabaaabbabbabbbabaabbb", "aabaaabbbbbabbaabbababaabbabbabaaaab", "abbabbabbbaabaabaaababaababbbbaaaaba", "ababbbbaaaabaaaaaaaabaabbababbabbbab", "baababbbbbaabbbbbabaabbbaaabbaabbbaa", "aaabbbabbaabbaaaaabbaabbbaaaababbbba", "bbbbbabbabbbbbaabaabbbbbbbaabbbbabaa", "aabbbbbbbaabbabbabbbbbaaabaaaaaaaaba", "aaabbabbaabbbbbbabbbabaaababbababbaa", "abaabbbaaabbbbbaabbaabbaaabbbbbbabbb", "abaababaaabababbbabbbaaaaaabbabbabba", "abbbaabbabbabababaaaababaaaabaabbaaa", "aabbbbabaaaaabaabbaaaaaabaaaaaaaaabb", "bbbabaabbabbaabbabababbabbbabbaabbaa", "baaaaaabababbbabbbababbbabaaaabaabbb", "abbababbabbbbbbbbbaaaabaabbaaabbabbb", "abbaabbaabbbbaababababbabbabbaaaabaa", "aabbbbbaababaaaaabbbabaaaababaaabaab", "baabbabaabbbbaaaabbbaabababbbbaabaaa", "aaaaabbbababaabbaaaaaaabaabbbabbbaab", "bbabaaabbababaabaaabaaabbaaabbbbabbb", "babababbabbbbbbababaaabbbbaababbaabb", "bbaababaababbaabaaababaabaaaabbaabba", "aabbaaabbaaaaaaababbaabbbbbbabaaaaba"}

{"Q", "T", "r", "h", "A", "e", "R", "J", "D", "I", "L", "o", "E", "N", "F", "C", "U", "V", "f", "d", "B", "G", "H", "n", "y", "O", "k", "a", "g", "j", "K", "M", "w", "i", "b", "l", "z", "p", "P", "t", "m", "u", "x", "S", "c", "v", "s", "q"}

{"aaababaababbabbaabababbbabbbabaabbba", "abbababaaaababbaababaaaaaabababababb", "bbbaabbbaabaaabbbababaaaabababababba", "babaababbbaaabaabaababaabaabaaaabbba", "babaabbaaaabbbabbaaabbbbbbbababbabba", "aaabbbaaaabaaaaababbabaaabbaaaababba", "ababbabbaaaaabababbaabbbaaaababbbabb", "baabababaaabaaababbaaababbababbaaaab", "aabbaaabbaababbaababaaaabbaaabababab", "aaaababbbaaababbbababbabbbabbabbaaaa", "aababbaabaaababbbabaaababaaabaababab", "abababababbbaababbaabbbaaaaaaaabbaba", "bbbabaaabbbaaabbaabbabaabaabaaaabbbb", "bbbaabbaaabaababbbbbbabaabaabaaabbaa", "bbbabaaaabbaabbabbababababbaabbbbabb", "baabaabaababbbbbbaabaabbabaabbbabbab", "abbabbbbbbaabbbaabbbbabaaaaabbabbbbb", "baaaabaaabaaababababbabbaabbbbaaaabb", "abbaaaabbaaabaaaabbaaabbbbbbbaabbbbb", "baaaababbbabbabaabbabaaaaaababababaa", "aaabaabaabbbababaaababababbaabababbb", "bbabababbaabaaaaaaaabaaabaaaaaabbbbb", "bbbbbababaaabbaabaaaaabbbbaaabaaaaab", "babababbabbbbbbbbaabababbbbbbbbbaaba", "bbbbaabaababbabaaababbaaaaabbbbabbaa", "aabbbbabbbabbaabaabbabbaaabababbaaaa", "abaaabbabaaaabababaaabbbabbaabbbaaab", "abbbababaaabbaaabbbbbbbaabababaaaabb", "aabbbbbbbbbababbaaabbbaaaabababaaabb", "baabaabbabbbaaaabaabbabbbbabaaabbbab", "aaabababaabbaabaaabbbabbabaaaababbba", "bbaabaaabbbaaaaaaabaaabababbabbabaaa", "ababbabbaabbbbbaaaaabbaaaabbaabbaaaa", "bbbabaabababbbbabbaabababaaabbaabaab", "abbbbabbaababbbbbababbbbbbbaaabbabbb", "baabaababbbbbbbaaaaabbabbbaabbabbabb", "babaaaaabbaaabaabbbaabaaaaaaabaabbbb", "abbbbabaaaaaaabaaaababaaaaabaaaaabba", "bbbaaaaabbabbabbbbaabaabaabbabaabbba", "abbabbababaababaaaabbbabbaaabaaabbab", "baabbaaaabbabaabaaaabababbabbbbaabba", "aaaabbaabbbaabaaaabaaabbbabbbbaaaaaa", "aababbabababbbabaabbaaabbbbbaabaaabb", "bbbaaaabaabbaaabbaabaaabaaaabbbaabba", "baabbbabbbbbabbababbabaabaabaaabaaaa", "aaaaabaaaaabbabaababbaabababaababbaa", "bbbbbabbbbaaaabaabbbaabbbbbaababaaba", "bbbbabaabbaabbabaaaabaaaaababaaaaaba"}

"i"

Returns: "D"
{"r", "K", "m", "L", "D", "i", "k", "l", "w", "x", "p", "v", "E", "b", "y", "t", "C", "e", "o", "A", "j", "I", "n", "H", "B", "J", "q", "G", "g", "a", "c", "h", "u", "s", "z", "d", "F", "f"}

{"bbbababaaabababbabababaaaaaaababa", "babbaaaaabaaaaabaaabaaabbbaaaabab", "ababaaaabaababbaaaaababbbbbbaabba", "aabbbaaababaaababbaaababaabbbbbab", "aaaabababbbaaaaabbbabbbbabbbabaaa", "aaabbbababababaababbababbaaababaa", "aabbbbabaaaababbbbbaabbaabababbaa", "aaaaaaababbbaaabbaaabbbabaabaaaaa", "babababaabbbbabbabaaabbbabaababab", "babbbababaababaaababbbaaaaabbaaaa", "bbbbbaaababbaaaababababbbbbaabaab", "aabbbbabbbbbaabbbababbababbbabbbb", "baabababaabbabbaaababbbabbbabbaba", "baabbbabbbabbabbaabbbaaaabbbaaabb", "bbbbaaabbaaabababbbbbbbabbabaaabb", "babbbabaabbabbbbaaabbabababbabaaa", "bbbbabbbaaaabbabbaabbbaabaaabbabb", "bababaabbabaaaabaaabaaaabbbaabbba", "aabbaaaabaaabaabbaabbbbbabaaabbba", "aaabababaaabaaaabbbabbaaababbbbab", "babaabaaaaaaaabababaaaabbaabbbbbb", "babaabaaabaabbabbbbbbbbbaaabaaabb", "baaaabaabaabaabaaabaabbbbbaababab", "aaaabaabbbbaaabbbabbbbaabbaaababb", "bbbbbaaabaababaababababababbabbab", "abaabaababbbbababaababbaababbbaab", "aababaaaaabbabaababbaaabbababbbab", "abbbbbbaabababaabbbbbabababaabbaa", "babbbbbaabbbabbbbbaaabaabbaaabbab", "babbbabbabbbbabababaabaaabaaababb", "baabaabbbbabbabbbbabbbbababaaabaa", "aabbbbaaabbabaaaaaabaabbaabbbbaab", "babbaaabbaaaaaaaaabaababababaabab", "bbbbbbbabbabbbbaabbababbabbbabbab", "bbbaaabaaaaababbbbbaababbbababaaa", "babababbbbbabbbbbaaaaabbbaaaaaaba", "aabaabbaabaabbbababaaaabbaabaabba", "baababbabbbbbbbabababbabbbaababab"}

{"e", "r", "g", "n", "k", "H", "i", "m", "w", "h", "A", "q", "C", "j", "c", "y", "E", "t", "p", "F", "d", "G", "B", "l", "I", "a", "x", "s", "J", "v", "D", "f", "b", "z", "o", "u", "L", "K"}

{"abaaabbbaabbbbbababbababbbbbabaaa", "bbabaabbaabaaaabbbbbbabbbaaaaabba", "babbbabbbbbbbbabbaaaaaabbabbbbbab", "bbababaaaababaababaabbbbaaabbaaab", "baaaaaaaaaabbbabbbaaabbbbbbababab", "abbbbaabbbabbaaabbababababbabbaba", "bbbbbabbbbbbabaaabbbaabaaaabbbabb", "bbaaabbabbbabababbbaaaababaabbbba", "bbaabbaabbaaabaaabaaaabbaaabbbbbb", "bbbbbabaaabbbbbbbaaababbaaabbaabb", "baaaabaabaabaababbbaaaaaabbabaabb", "aababbaabbbababbabaabbabbbbaabaaa", "aaaababbbbbaabaababaabbbaabbbbbaa", "aabbabbaababababababaabbabbbbaabb", "bbbbbbbbaaabbbaabbabbbbaaabbbbabb", "ababaaabbbabaabaabaaabbaaabaabaab", "bbbbaaabbbaaaaababbbbaabbaaabbaba", "bbbbaabbbabbaabbabaabaabaabbbbbba", "ababbaaaaaabaabbabaaabababababbab", "babaabbbbbaabbababbbbbaaaabbababb", "aabbbaaabbbbaaaaabaaaabaababbbbbb", "aaabbabbaaabbbbbabaabbabaabbbabab", "abaaabbababbaabbbbaabbbababaabbaa", "abbababaabbabaaabbaaabbabbaaaabaa", "abbbbabbabbbaabbbabbbabaabaaaabaa", "aaaaabbbaabababaababaabbbabbbabaa", "abbabaabaabaaabbaabbaabaabbabbbaa", "bbaabbaabbbabbbbbbbaaabaabbbbbaab", "aaabababbabababbbababbabbaaabbabb", "baababbabababaaabbbabbaabbabbabab", "ababbbabbbbbbbbaabbaababbbbaaabba", "bbbbaabaabbaaaaabbaaabbababaaaaab", "bbbbbaaabbabbbbbbaababaaaabbabaaa", "bbabbaaaabbbabbaaaababbaaabbababb", "baaabbabbbbbaaabaabbabbbaaababbaa", "bbabbaabaabaabbbbbababbaaabbabbbb", "aaababbaaaaabbbabbababbaaabbababa", "bbabaaabaaababaabbabbbbaaabaababa"}

"l"

Returns: "l"
{"b", "l", "n", "p", "q", "i", "s", "a", "d", "k", "m", "r", "e", "c", "g", "f", "j", "o", "h"}

{"aabbbbabaaa", "baaababbabb", "abbabbabbba", "babbabbbbaa", "bbbbabbbaab", "ababbaaaabb", "bbabbbabbba", "bbabbbabbab", "bbaaabbbaaa", "baabbaabbba", "baaababbbab", "bbaaaababbb", "aaabbababaa", "bbbbbabaabb", "bbbbaaaabbb", "bbaaabababa", "aabbbaaabbb", "bbbabaabaab", "aabaabababa"}

{"e", "s", "f", "r", "g", "i", "p", "b", "n", "d", "h", "q", "a", "c", "j", "k", "m", "l", "o"}

{"aabbbaababa", "bbababbabba", "abbabbbaabb", "aaaaaaabaaa", "abbbbaaabba", "abbbbaabbba", "aaaabbaabab", "aabaaabbbab", "baababbaaab", "aaababaabba", "babbbbbabaa", "bbbaabbabbb", "abbabbabbbb", "abbbbabbbba", "aababbabbaa", "bbbaabaabba", "abbbbbaaaaa", "bbbbaaabbaa", "aaaabaaabab"}

"k"

Returns: "c"
{"q", "g", "Q", "b", "G", "A", "L", "h", "F", "j", "M", "p", "y", "d", "O", "t", "f", "a", "e", "l", "S", "m", "R", "C", "k", "J", "v", "c", "z", "n", "w", "r", "I", "B", "K", "E", "i", "x", "P", "s", "o", "N", "H", "u", "D"}

{"bbbabaaabbbbababbaabbabaababaabbabbbaabbabbbaabbbb", "bbbababbaaabbbaaabaabbabbbbbbaaaaaabbababaababaaba", "ababbbaabbabbbabaaabaabaaaaaaaabbababababaaabbbaba", "baaabaaabaabbaabaabbbbaaabbbababbbbaaabbabbbbaabab", "abaaabaaaabbabaaabbbbababbaabbabaaaabbabbbbbbababa", "baabaabaaababbbbbbbabaabaaabaaabaaabbbbaaaabbaaaaa", "bbbbaaaabbbaaaabbbbbababaababaabbababbaabaabbaaabb", "babbbbabbbbbbbbaaaabbbabababbbaabaaabbbbaababbbbba", "bbaaabaabbaabbababaaababbbabbabaabbbbbbabbaaaaabaa", "bbaaabbaaaaabbaabbbbbaabaabaaabbbbaaaabbbbbbabaaba", "bbaababaabaabaababaabbaaabbaababbabaabaaabaabaabba", "bbaabbabbbaaabaaaabbbaaabbbabbaaabbabbbaaabababaab", "bbaababbaaabbbaaaabbbbaaaaabaaabaabbaabbaabaababaa", "aabbbbbaababaaaabbabbbaaaabbaabaabaaaabaaababbaabb", "aabbbabaaabbbabbbaabbbabbbabbbababbabaaabbaabbbbab", "bbabbbabbbababbaabbbbbbaabbabbbbaabbaabaababbbbaab", "babbabaaaaabbbaabbbbaabaababababbabaaaaababbbababa", "aabbabbaaaabbabaabaabbbaabaaaaabaaabbabaaabaababab", "baaaabbaabbaabbbbaaaabbabbaaabaabaabbaaabaaabbabaa", "bbbabbabbbbabaaababbabbaaabbabbabbaabaabbbbbabbbba", "aaabbababbaabbaabaabaaabbbabbbaabababbbaabababbaba", "bbaabaaabaababbaaaabaabaabababababbbbbbaaaaaaaabba", "bbbabbbabbabbbabaaaabaabababbbbabbbbaababaaabbbbbb", "aaababaaabbaabbabaabaabbbbbabbaabbabaaababbabbabaa", "aaabbabaaaabbabaaabaabbabbaababbaaabaabbbaaaaaabbb", "abaaabaaaaaabbabaaaabaaabbbbabbbaaabbbbbbaababaaaa", "bbbbbbbaabaaabbaababbbbbaabbbbbaabbaaababbaaaabaab", "abababbbbaabaaaaabaaaabbbbababaaababbaabbaabbbabba", "abbbbbbabbbabaabbaabbbaaabbaababaaaabbbabaaaabbaab", "baaaaabbabbabbaaaababbabbaaaabbaabbabaaaaabaabaabb", "bbaaabaabbaaaababbaaabbabaaaababbbababbaababbbabaa", "abbabaaabbbbaaabbbbbbaababaaababbaaaaaabbbbababbbb", "bababaababbbbbaaabaabbbabbaabbababbabbaaaabaaabbab", "babaaaaaaaababbabaaabbbaabbbabaabbababaabaabbbabab", "aabaaaaaabbabababbaaaaabbaaabaabbbbbaaabaaabbbbbab", "bbbaabaaabaaaabbaabbbaabbbbbbabaabbbaabaabbabbaaaa", "bbbaabbabbaabaaabbbbababbabbaaabbababbabbbaaaaaaba", "abbbaaaababababababaaaaababaabbbbbbabbbaaaabbabaaa", "bbabbbaabbbabaabbabaaaaabbaaababababaabaabbaababbb", "ababbaaaabaabaabaaabaaabbaaabbbabaaaaabbaabaaabaaa", "baabbbbbbbaabaababbabbbaaaaabbbbaabbbaaabbbbbbaaab", "aaaaaaaaaabbbbbbbabbababbbabaaabbaaabbbabababbbaaa", "bbbbbbbbaaaaaaabbbbbababbbbabbbabaaaabbabbbbbbbbba", "abbaabaaaabbbbbbbbbbbbabbbbbbabbababbbbabbabaababa", "bbbabbbbaaaaabbbaaaabbbbabbabbbabaabababbaaaabbbaa"}

{"x", "d", "Q", "v", "g", "O", "f", "j", "r", "N", "S", "m", "A", "K", "o", "z", "F", "e", "E", "a", "J", "l", "R", "h", "D", "M", "b", "I", "G", "H", "q", "C", "n", "w", "s", "L", "P", "c", "k", "t", "i", "u", "y", "B", "p"}

{"abababababbabbbabbaabbbbbabbbbbaaaaabbbaaabbbabaab", "bbbabaaaabbbbabbaaabaaaaaabaaabaaaabaaabaabbbabbbb", "ababaaabaabbaabbbbabbbabbabaabbabbabbbbaababbababa", "baabbabbaaaababbbaababaabbbaabaaaababaabaaaaaaaaaa", "baaabbbbabbabaabbaabbabaabababbbababaaababbabbbaaa", "baabaababbaaabababbbbbbbbbabbaababbbabbaabaabbbaba", "abaaaabaabbaaaababaaabbaaaabbababbaaabbaabbbbbbaba", "babaaaabaababaaabbbbbbbaabaaababbbabbabaaabaaabbaa", "baaabbabaabbbbabaabbbbbbaabbbbabbbaabaaaababaaaabb", "aaaaaaaabbbabaabbaabaaaabbbaabbbbabbabaabbabbbabba", "aabbaabbbabbaabbbbaabaabaaabaabbbbbabbabbabbbaabbb", "bbbbbbaaabaaabbababaaaabababaaabababaaaaabbaababbb", "bbaaabbbabaaabbbbbbbaaabbaabbbaabaabbabababaaaabba", "aabbaababbabbbbbabbaabaaabbbbbabbaababbaabaaaabaaa", "abbbbbabbbaaabbaabbbaaabbbbbbaaabbbaabababbbbabbaa", "aaaababbbbaaaabababababbbbababbbbbbaaaabbbaabbbaab", "aaaabbbbbabbbbabaabbbabbbbbbababaababbbbabbaaaabbb", "aaabaaabbbbababbabbabbbbababaaaababbbaabbaaaababab", "babbabaabbaabababababababaabbaabbbbbbabbbbababaaab", "abaaabbbaabaaaabbaabaabaabbbaaababbabbbbaabaaabbaa", "abbabaababbabbaabaaaababbbbbabaabbbaabaaaaaababaaa", "bababaaababaababaabbababbbaabaababbaababbbaaabbbba", "ababaaabaabbaaaaabbaababbaaabaaabaaabaabbbbbbaaaba", "bbabaababbbaaabbbbbabaabbbbbbbabbbaabbbaabbabbbabb", "aabaababbaaaaabaabbbaaaabaabaaaabbbbbbbbbababbabab", "aaaaabbbbbbbbbbbaaababbaabaaaaabbaabaababaaabbaaab", "aabababbbbbbabbabbbaabaabaababbabbaaaaaabbbbbababa", "ababbbbaabbbaababbbaabbaaaaababbbababbabbbababaaaa", "abbbbababbabbabbaabaaaababaabbbbaaaaabbaaaaaaaabab", "aaabbaabaaaaababaaabaaaabababbbbbbbaabbaabaabbbabb", "bbbaabbbabbbbabbbbabbaabbaabaaababbaabaabbbaaaabab", "aaaabbababaaaaabbbabaaababbabbbbbbbbbbaaabaaabbbab", "aabbaaabbabbbabbbbbabaabbaabbaaaaababaabbbaaaaaaab", "abaababbbabbabbbaaaaaabbaabbbbbbababaababbabbabbaa", "ababaabbbabbbbbaaaabaaaaabbabaaaabbbbbaaaaaaaababb", "baaaaaaaabbbaabbaababababbbabbaaaabaabbaabaabbaaba", "babbabbbbbbbabbbaababbaabaababaaabbbabaaabbabaabbb", "aaabbbbbababbabababaaabbabbbbababbbbaaababbaabbbba", "bababbbbbbbbbaabaaabbaaabbbabbaaaaaaaabaaababbbabb", "aaaaabbabaaaaabaababbbabaaababbaaabbbaabaabbaabbaa", "bbaabbaabaabbbbababbbbbbbabaabaaaabbbbabbaaabbabbb", "abbbbbaaabaaaabbaaabbaaaabbbbaabbbbbbabababbaaaaaa", "abbabbaaaababababbbbbaaababbabbaabaaaaaabaabaaaaba", "aaabababbbbbaaabbababbaababbabbbaaaaabaaabbbbaabab", "baaaabbabbbaababbbbbbabbababaaaabbbbbabbbbbbaaaaaa"}

"g"

Returns: "r"
{"a", "e", "c", "d", "g", "b", "k", "i", "j", "h", "f"}

{"baaabaaabbaabbababbaaab", "abaaaaaaaababbbababbbab", "bbbaaaababbbbabbabbaaba", "baabbbbabababababaababa", "baabaaabbabbaabbaabaaab", "babbbbbaaabbabaaababbaa", "ababbaaaaaabaaabbbbbbaa", "baaabababaabaababbbabab", "bbbababbaaabbbbaabbabbb", "baabbbabbbbaaabbbbaaabb", "abbabbabaabababbbaabbbb"}

{"b", "j", "k", "a", "d", "f", "g", "h", "e", "c", "i"}

{"babbbababababaababbbbaa", "bababbbbbaabbbaabbaaaab", "babbbbabababbabababaaab", "babaababbabaaabaaabbbba", "bbaaabbbbbbaaabbbbbabaa", "aaaabbbaabaaaababaabaaa", "bbbaabaabbabaaabaabaabb", "babaaaababbabbbbbaaabba", "aaababbbaabaaaabababaab", "aaaaaaababbbbbabbbbaaaa", "abababbaaabbbbabaabaaba"}

"d"

Returns: "f"
{"K", "I", "d", "L", "M", "y", "O", "q", "G", "g", "P", "t", "e", "n", "N", "o", "x", "m", "z", "w", "J", "B", "a", "b", "F", "v", "H", "u", "E", "D", "r", "h", "p", "A", "C", "f", "k", "s", "i", "l", "c", "j"}

{"aabaaaaababaabaabbbaaabbabaabbaaba", "abbbbbbbaaaabbabbbabbabbaabaabbabb", "babbbbaaabbabbbababaabaabbbbabbaaa", "bbabababaaaabaabbbbaaabaabaaababba", "bbaaaaabbaaabababbbaabaaaaaaaabaaa", "abababaaaabaababbaaaabbbbbbbbaaaaa", "bbabaaabbaaababaabbabbbbbaaabbabba", "aaaaabbbbaaabbbabaaaabaababbabaaab", "baababaaabaabaaaabbaaaaabbbbaaaabb", "aabaabababbbbbaabaaaabaabababbabaa", "bbbbaaababbabbbbaaaaabaabaaababaab", "aaababaaabbbaababbababaaaaaaaaabab", "bbaabbbbababbaabaaababaaabbbabbbbb", "abbbbbbabbaaabbbbbbbabbbbbabbbaaba", "babbbaaabbbbaaabbbbbabbababbababbb", "aababbaaabbbabbbbaababbababbaabbbb", "abbabbbbabbbbabaaaabbaaabaaababbbb", "bbbaaabaabbbaaabababaaaaaabbbbbaaa", "bbbbbaaaabaababbabbbbbaaabbaaaaabb", "aaaabbbabbabbbbbaababaabbaaaabaaaa", "aaaaaaabababababaabbbbbbbbbaaaaaba", "abbbaabbbbaaaababbaaaabbbaaabaabaa", "aaaaaabbaabaababbaaaabaaabbbabaaaa", "baabbbaaabaaabaaaabaabaaabbbbaabaa", "bbabaaaabababaaaaababbbbababaaaaab", "bbabbbbaaaaabaaabaabaaabbbbbabbbaa", "baabaaaabaabbbbaabaaaabaabaaababbb", "bbabbabbaabbbabbbbabaaababbbbbbbab", "bbabbaaabaabaababbaaabbaabbbaabaaa", "bbbababbaabbaabaabbabaaabbbbaaaaab", "abbbbabbabbbabababaabbbaaabbaaabab", "aabbbbbbaaaababababaabbbbbaaaabaaa", "aabbbabbbabaabaaabbbabbbbbbabababb", "ababaabbaabbaabaaabbbbbbbbaabaabab", "bbbabbbabbaababbbaabaabbbababbbaba", "bbbabbaababbaabbabaabaaabbabababba", "aabbbaabbbbbbaaababbbbaabbaaababaa", "bababbbbbabbabababababbaaabbaabaab", "bbbbabaaababbaabbababbabbababbaaaa", "bbbbbaababaabbababaabbbaababbaaaaa", "bbbabbbabbbaaaaaaabbabbaaaabbbabba", "aaabbabaabbabbbaabbbaabbbaaabaaabb"}

{"B", "n", "E", "P", "J", "r", "q", "t", "M", "N", "d", "u", "w", "z", "K", "H", "F", "c", "i", "g", "L", "j", "h", "k", "m", "x", "C", "O", "b", "v", "D", "A", "I", "l", "G", "o", "f", "e", "y", "s", "a", "p"}

{"bbababababbbababaabbaaaaaababababa", "aabbbaaaaababaaaaabaaababbaabbbbbb", "baabaabbbbaabbbbabaaabbbbababbabba", "babaabaaababbaaaaaababaabbabbaaaaa", "abaabababbabaabaaaaaabbaaababaabab", "baabbaaaabbabbbbabbbbaaabaababbbba", "bbbababaabbabbbabbaabbbaaaababbbba", "ababaaaaabaaabaaabbbabbbbbababbbaa", "abaabaaababbaaabaabbabbbabaaababbb", "abbabbaaaaaaaaabbabbbababbaabbbbba", "bababbbaaabbbbbaaabaaabaabbbbbabab", "aababbbaabbaaabbabaabaababbbabbaaa", "baaabaababaaababbabaaabaabaaabaaba", "abaaabaabaabaaabbbbababbaaaabbbbbb", "ababbaabbbbabbbbaaabbbbaabaaaaaaaa", "abaabbabababbababababbbbabbabaaaab", "aabbbaababaaaaabaababbaaabbabaaaaa", "abbaababaababbabbbbbaaabbabbbaabbb", "baabbabaaaaaaaaaaabaaabaaaababbaab", "bbbababababbbbbbbaabaaabbbbbbababa", "abbabaabababbaaaabaababbbaabbaabba", "aaabbbaaaabbbbbbbabbabbabaabaaabab", "aaabbabaaabbababbababbbabaabaaaaaa", "bababaaababbbbabaababbaaabaaabaaab", "baabaabbabaabaabbbbabaaaaabbbbbbaa", "aabbaabaabbabbbbaabababaabababbabb", "ababbbbbaabbbabababbaababbababbbba", "bbbbabbbaaaaaabaaaabbabbbabababbbb", "bbabbabbbabaaaabbbbbabbbabbbbbaaba", "baaabaaaabbaabaabbbbaaaababbbbabab", "bbaabaaaaaaabbaabaaabbbababbbbbbab", "abababababaaaaaabbabbaaababbbbbbaa", "baabbaabaaaabbbbbaabbbbabbbabbbaba", "aabbabaababbababaabbbbbababababaaa", "baabaaaaabaaaaabbbbababbbaabbabaaa", "aabababababaaabbbbbabbbbabbbbbbabb", "abbbabbaabababbabbaaabaabbabaaaaab", "bbbaaabbabbaaababbabaaaaaababbbaab", "bbbbabbbbababababbabbbabbaaabbabba", "baabbaaabaaaaababaaabbabbbabbbaabb", "babaababaabbbaaabbbbaaaababababaaa", "abbabaaabaabbbbababbbaaaaabbabbabb"}

"B"

Returns: "E"
{"y", "v", "s", "m", "p", "e", "w", "c", "E", "g", "r", "B", "h", "x", "d", "b", "j", "u", "D", "i", "q", "t", "f", "n", "k", "a", "l", "o", "z", "A", "C"}

{"baaaabaababbaaabbabbaaaabbbbabbbbbaaaababbbab", "aaaabaabbbabbabbaaaaaaaabbabbababbbbbbabaabbb", "babaabbbaabbabbbbabaababbabbaabababababaabbaa", "bbabaabbabaaabaaabaaaabbbaababbbbbbaababbbbab", "bbabaaabbbbababaabbabbbaabaaabbbabbbabbabaaaa", "baabbbbabbaabbbbaabbabbbabaaaababbbbbbbababbb", "aabbaabababababbbbaabbabbbabaaaabbbaaaabaabbb", "aaaabbbbbabbbaabaaabbbaaaaaaaabbbaaaaabbaabbb", "abaabbaaabbbaaaabbaabbbaaabbbabaabaabbabaaaab", "baabbbbbbaabbbbbbabbbaaabaabaabbabbaaaaabbaab", "aabbbbaabbabbaaaabababaaabbaabbbababbbbaaaaba", "aabbbbbabbbbbabababbabbbbabababbbbbbabbbbaaaa", "aabababbbbbbbabbbbbaabaaabaaaababbaaababbbabb", "baabbabbaabbbbabababaabbabaaaaaabbbbbabbbbbab", "bbbbbabbaabaabbbaaaaaaababbbababaabbbaaaaabab", "bbabbaabaaaaaabbaabaaabbbaaaaababaaabaabbbbab", "bbbaabbabababbbabaaaaabababbbababbbaaabaabbaa", "baaababaabaabbabaaababbbbbaaababbbbabbbbabbab", "bababbbabaaaaabbaaababbabbbaaababaaabbabbaabb", "bbbaaaabaaabbaabbbbabbababaabababbbabbbbbaaab", "aabbbbabbaabbbbaaaabbbabababaababaabbaabbabab", "baaababaabbbbabbbbabbabaaaabaabbaabbbaaabbbab", "babbaababbabababaaaabaababbbabbabbbaabbabbaba", "abaabaabaaaabbbaabaababbbbbbbbababbaaabbaaabb", "bbababaaaabbbbabbbababaabbaaabbbaaaaabbbaabba", "ababbbbbbaaabaababaababbbbbaabaaabbbbbaaaabbb", "bbaaaabaabbaababaaaabbabaababaababaabbaabbaba", "aababbbbbbabbabbabbbbbbaaabababaabaaaaaaaaaaa", "bbaaabbbbaabaabbbababbaaabbabbbabaaabbbaaabba", "baabbabbaaaaabbbaababbabbaaaabbbabbbbaaaabbaa", "bbbaabababbababbaaaabbbabbaabbbabbabbbaaaaaab"}

{"k", "d", "E", "e", "v", "l", "g", "b", "f", "r", "w", "c", "x", "a", "u", "t", "n", "C", "o", "i", "A", "z", "D", "s", "q", "B", "y", "h", "j", "m", "p"}

{"aabbbbaaaaabababaaaaaaababbbabaabbbabbbaaaaaa", "ababbaaabbbaaaabaababaaaababbaaaaababbabaabaa", "aababbabbabbababbbaababbabbabaabababababaabba", "bbbabbaaabbabbbababababbbbabbababbbaababbabab", "abbbbbbabaabaaaabaabaabbbabaaaaaabbabbbababaa", "aaaaaabbabbababaaaaaabbbbbababababbbaabaababb", "aabbaaaabaabaabbbabaaabbbbbbabbaaabaabbbabbbb", "aabbaaabaaabababbbbabaaaaaabbababaabbaabbabaa", "bbbaabbbabaabbabbabbbbaabbaaabbaabababaababab", "bbaaabbbbaaaabbababaabbabbbbaaababbaaabbaaabb", "abbbbabbabbabbbbaaababaabbbbbaaabbbaababbbaaa", "abaabbbbbabbaabbaaababbbbaababaaaaabbaabbaaaa", "bababbbbbbaababbabbaababbbbabaaaaaabbbbababab", "baabbabbabaaabbabbbabbbbbbbaabbaaaaabbbbbbaaa", "bbbabbaababaabaaaaabaabaabbbbbbabbabbbbaaaaaa", "bbbaabbbabaabbabaaababababaaaababbaabaabababa", "baaabbbaaabaaabaaabaaabaabaaaaababaababbbbabb", "aaaaaaabbababaaabbabbbbaaabbbbbbabaabbaaabaaa", "abbaabbabbaababbbabbaaaaabbabaabbaabaaabaabba", "bbaabbabbaabbbababaaaabbaaaaaabbbbbbaababbbab", "aaaabbabbaabbbabaababaabbaabbabbbababaababbba", "baababbaaaaabababaaaaabbaaaabaabbbbaaabbbabab", "baaaabbbbbabbababaabaabaaabbbbbababaabaaabbab", "ababaaabbaababbbbaabbbabbaaaaaaabbbaabaabaaab", "abbbbaaabbabbababbaaababaaabbaabbaaaaabaabbba", "baabbbaabaaaabbabaababaababbbbbbaabaabbabbbbb", "bbaaabbbabbbbbabbbbaaabbbaaaaaabbbbaaabbabaab", "aaabaaaaabbababbabbabbbaaaabbaabbbaaababbaaab", "aababaabbbbbaaabaaababbabaaababbaaababbabbaab", "aaaabaabaabbabaabaabbbbbaabbaabaaaaabbbabbbbb", "abbbaababbaaaabbbbabbbbbaabbaaababbaaaaaaabba"}

"h"

Returns: "h"
{"t", "b", "q", "e", "o", "d", "p", "i", "w", "a", "u", "f", "n", "h", "r", "l", "s", "k", "j", "g", "v", "c", "m"}

{"abaabaa", "bbaabba", "abaaaab", "bababba", "ababbaa", "bbaabbb", "ababbba", "ababaaa", "aaaaaaa", "babbbbb", "baababb", "babaaba", "aabaabb", "ababbaa", "bbaabba", "babbbba", "babaaaa", "bbaabaa", "abbabaa", "babbbba", "ababbaa", "babaaba", "bbbbbaa"}

{"e", "k", "v", "d", "g", "s", "u", "q", "h", "p", "t", "a", "l", "j", "o", "w", "f", "i", "n", "c", "m", "b", "r"}

{"baaaaab", "ababbab", "aaabaaa", "bababbb", "aaabbab", "bbbbaab", "babbabb", "bbababb", "bbababa", "aabbaab", "bbaabbb", "bbbabab", "bbabaaa", "abababb", "aaabbbb", "bbaaabb", "ababaab", "babaaab", "aababaa", "aaaaaab", "aabaaaa", "abbaaab", "baabaaa"}

"j"

Returns: "a"
{"t", "f", "z", "G", "O", "m", "k", "i", "U", "b", "P", "l", "I", "K", "o", "D", "E", "S", "T", "M", "R", "s", "L", "H", "y", "C", "j", "v", "x", "a", "A", "n", "F", "w", "N", "u", "h", "q", "d", "c", "p", "e", "g", "B", "J", "r", "Q"}

{"baaaaab", "abbabba", "bbaabaa", "bbbabbb", "bbbbbaa", "aabbaaa", "bbabbba", "aaabaaa", "aabbaaa", "bbbbaba", "abbbbba", "babaabb", "abbabaa", "abbabba", "aaaaaaa", "abbaaba", "bbbbaaa", "aaababb", "baababa", "abaabab", "ababbab", "aabaabb", "baaaaba", "baaabba", "abaabaa", "bbbabab", "baabbbb", "bbaabab", "abbbbbb", "aabbaba", "baaaaaa", "aabbbab", "bbabaaa", "aaababb", "abbbbaa", "bbbabab", "aaaaaab", "baabbba", "bbbabaa", "bbbbbbb", "bbbaaaa", "bbbabbb", "baabbbb", "bbbbbaa", "abababa", "baaaaab", "aabaabb"}

{"a", "n", "s", "B", "E", "i", "y", "p", "q", "k", "l", "J", "e", "h", "R", "o", "C", "c", "x", "f", "M", "K", "Q", "m", "G", "t", "j", "b", "N", "v", "I", "D", "L", "O", "T", "z", "F", "P", "w", "u", "g", "r", "H", "U", "S", "A", "d"}

{"babaabb", "bbbbaba", "bbababa", "bbbbabb", "abaaaba", "baaabbb", "baaabba", "bbbbaaa", "baaabab", "aaaabaa", "abaaabb", "bbabbba", "aabaaba", "bbbabab", "aabbbaa", "aaaabba", "aaaabaa", "abbabba", "babbbbb", "bbabbab", "abaabaa", "bbbbaaa", "bbabbaa", "bbaaaab", "babaaab", "abbabab", "aabaaab", "bbbaabb", "aababaa", "abbaaba", "aaabbab", "bbbabba", "baabaab", "abaabaa", "aabbaab", "aabbaab", "babbbba", "bbabbbb", "babbbba", "bbabbab", "babbbba", "baaaaba", "aaabaab", "bbbaaab", "aabbbab", "aabaaab", "bbbbaaa"}

"f"

Returns: "o"
{"e", "d", "g", "h", "a", "i", "b", "f", "c"}

{"babbbbaabaababbbabbbaabbaababaabbabbb", "aaababbbbaabbabbaababaabbaaabaaaabbab", "aaaabbbbaababbbbabaabbaaaaaaaaaaababb", "baabbbbbbaaaabaabababbabbbbaaabbbbaab", "bbaaaaaaabbabaabbbaaaaaaaabbbbaaabbab", "bbabbaabababbabbbbbaaaababbaabbabaaab", "abababbaabaaaaaabbbaababbbbbabaabbaaa", "bbbbbbababaababbbaaabaabbbaababbbabaa", "baaaaabbbbaaababaabaabaaabbabaaaaaabb"}

{"c", "g", "i", "f", "d", "b", "e", "h", "a"}

{"bbaababbbaababbbaabaaaabaaabbaaaabbba", "bbaabbbabaabbbababbababbbaaabaaaaaabb", "babbbababbabbaabbaababbbaababbbbbaaba", "bbbaabaabaabaabbbaabbaababbaababbbbbb", "aabbaabababbaabbbabbbbaababaaaaaaaaab", "baaaabaaabbbaaaaabbaaaaaabaabbbbbbbab", "aababbaaaaaabbaaaaaaaaaaabbaaaabbbaba", "aabaaababbabbababbbbabbbabaaaabaababb", "baababbaaabbbababaabaaabaabbaaaaaaabb"}

"a"

Returns: "b"
{"l", "d", "j", "f", "h", "g", "i", "k", "a", "c", "b", "e"}

{"abaaababbbabbbaaaabbbbbbbbbbbbaaa", "babbbababbbbabaaababbbbababbbabbb", "bbababbabbaaaabababbbbababbaaaaaa", "abaabababababbabbabbbaaaabbabbbbb", "abbabbabbababbbababaabaabaaabaaab", "bbaabbaabbababaaaaabbaaaabababbaa", "aaababbbaaabbabbbbbbabbbbaaaaaaaa", "bbbabbaaabbbbabbabbaabaabbabbbbbb", "babbaabbbbbabbbbaaabbbaaaaaaaabab", "aababaaaaaaabbaabbabbbbbabaaaabbb", "aabbbbbbabbbabbaabbbbaaabbbbaabab", "baaaabbaaabaaabaabbbaabaaaaaabaab"}

{"b", "k", "g", "i", "h", "d", "c", "l", "f", "a", "e", "j"}

{"bbabbaaabbabbaababaaaaabbbababbab", "baaabaaaaaaaabbaabbbababaabbbaabb", "aabababaaaaabaaabbbaabaabaabbbbba", "abaaabaaaabaaababbaabaabaaabbaaaa", "abaababababbaaaabbababbabbbbabbaa", "abaabbaaaabbabaabbaaabbbbbbaabbaa", "bbbbbbabaaaabbaababbbabbbbbaabbbb", "aaaaaaabbababbbbbaababbbaabbbbbbb", "babbaabbbaaaababbababbaababbabbbb", "baabaabbabbbababbaaabaababaabaaaa", "aaaabbbabbaaabaaababaaabaaaaabbab", "abaababbbaabbbbaabaaaabbbaaaabbba"}

"e"

Returns: "e"
{"q", "M", "w", "y", "p", "N", "s", "r", "a", "H", "o", "n", "F", "m", "l", "b", "D", "j", "C", "u", "f", "I", "g", "L", "i", "x", "A", "G", "O", "k", "h", "d", "c", "E", "B", "v", "J", "z", "K", "e", "t"}

{"aabbaaabb", "baabababb", "bbaababba", "bbbaaaaaa", "abaaaabaa", "bababbbab", "abbaabbaa", "aabababbb", "bababaaaa", "abbababaa", "aabbbbbba", "bbabbabab", "babaabbba", "babbabbbb", "baaabbbbb", "baaabaaaa", "aaabbaaab", "abbaabbbb", "abbabbbab", "bbaaaabba", "babbaaabb", "aabbabbab", "baaababba", "ababaabab", "bbbaabbab", "aaaabbabb", "babaaaaaa", "abbbbaaab", "aabaaabba", "bbbaaaaba", "bbbbbbaab", "aabbaaabb", "aabaabbab", "aababaaba", "bbabbbbab", "abbabaaab", "babaaabbb", "bababbaaa", "aabbaabaa", "baaabbabb", "bbbbbbbbb"}

{"m", "k", "n", "q", "L", "E", "M", "l", "w", "x", "g", "e", "i", "z", "F", "r", "a", "h", "f", "D", "J", "K", "j", "v", "A", "t", "N", "y", "s", "c", "o", "p", "d", "b", "B", "G", "O", "I", "u", "C", "H"}

{"bbaaabbba", "bbaaaaaab", "abaaababb", "baaaabbbb", "abbbababa", "baaaaaaaa", "aabbbbbab", "aaaaabbba", "baabababb", "babaaabab", "baaababaa", "bbbbaabba", "bbaabbabb", "bbaaababb", "abbabbaba", "aababaaab", "abbbbbbaa", "aabbaabaa", "bbbaabbba", "abbabbaba", "aaabbbaaa", "bbaabaaaa", "aabababbb", "abbbbabab", "baaabbbba", "bababbbba", "aababbaab", "bbaabbaab", "bbbaaabbb", "babbbbabb", "ababababb", "babaaabab", "bbaaaaaba", "aaaaabaaa", "abbaaabbb", "bbbbababb", "baabababb", "bbaabaaaa", "aaababbbb", "abbbbbbba", "bbaabbaaa"}

"o"

Returns: "C"
{ "anne", "Zoe" }

{ "a", "a" }

{ "bob", "chuck" }

{ "a", "a" }

"anne"

Returns: "chuck"
{ "F", "M", "S", "h", "q", "g", "r", "N", "U", "x", "H", "P", "o", "E", "R", "z", "L", "m", "e", "u", "K", "A", "w", "Q", "O", "v", "j", "a", "t", "p", "C", "G", "k", "c", "V", "B", "D", "s", "n", "i", "f", "T", "I", "l", "d", "J", "y", "b" }

{ "abaabbbb", "bbaabbbb", "aaabaaab", "aabbaaaa", "baabbaab", "aaababba", "bbabbbbb", "bbbabbba", "aaabbbba", "aabbbaaa", "abbabaaa", "babbabbb", "aaaaabba", "aaaabbaa", "abbbabaa", "babababa", "abbaaaaa", "bbababba", "baaaaaba", "baaaaabb", "bbbbabba", "ababbaaa", "abbbabab", "baabbbaa", "bbbaabbb", "aababbab", "ababbabb", "abbaabba", "baabbabb", "aaabaaab", "aabbbaba", "aabaaabb", "abababba", "aabbaaaa", "aabbabaa", "bababaaa", "aabaaaab", "bbbbaabb", "baaababb", "abaabbab", "aabbbaaa", "baabbaba", "bbabbbaa", "aabbbbaa", "abbbaaab", "abababbb", "ababaaba", "bababaaa" }

{ "f", "C", "v", "g", "Q", "z", "n", "c", "B", "o", "M", "F", "u", "x", "I", "T", "K", "L", "E", "U", "w", "A", "d", "t", "e", "R", "D", "s", "p", "q", "m", "r", "H", "j", "J", "V", "l", "a", "k", "h", "G", "y", "i", "P", "O", "N", "b", "S" }

{ "bbbaabab", "bbabaabb", "ababbbbb", "bbbababb", "baababaa", "bbaaabab", "abbabbaa", "bbbabbbb", "aabbabab", "abbababa", "aababbbb", "bababaab", "aaababbb", "baabbaba", "abaaaaab", "bbaababa", "babaabab", "abbabbba", "ababbbab", "baabbbab", "babbaaab", "abbbbaba", "bbabbbba", "baaabaab", "ababbabb", "abbbaabb", "bbbbaabb", "bbbaaabb", "baabbaba", "bbabaaab", "aabbbaab", "abbbbabb", "bbaaaaba", "bbbababa", "abbaabba", "bababbbb", "aabaaabb", "babbabab", "baaaabaa", "ababbaba", "aaabaabb", "bbaaabaa", "baaaaabb", "bbaabaab", "bbababab", "aabaaaab", "aaaaabab", "aabbaaba" }

"U"

Returns: "x"
{ "A", "B", "C" }

{ "a", "a", "a" }

{ "A", "B", "C" }

{ "a", "b", "b" }

"B"

Returns: "B"
{ "b", "a", "c" }

{ "a", "a", "a" }

{ "f", "e", "d" }

{ "b", "b", "b" }

"b"

Returns: "e"

Statistics

Problem Statement for "MatchMaking"

Problem Statement

Definition

Notes

Constraints

Examples