Candidate FCRS

01_readme.md

Candidate FCRS for presentations $\langle a, b \mid bUa=a \rangle$

This gist contains some artifacts relating to an experimental completion-like procedure for monadic one relation monoid presentations.

This procedure, if it succeeds, produces a locally confluent rewriting system with the following property: if such system is terminating, its normal forms are precisely the lexicographically minimal representatives of monoid elements under the generator ordering $a < b.$

Because of this, a termination proof of such rewriting system implies that the congruence class of each monoid element contains a minimum under the standard lexicographic ordering on words.

Data

Candidate systems were generated for 16383 presentations of the form $\langle a, b \mid bUa=a \rangle$ with $\left|U\right| \leq 13.$

The data is organized as follows:

• 02_nontrivial.txt contains 2037 candidate FCRS with length-increasing rules, these require a termination proof
• 03_shortlex.txt contains 12947 shortlex FCRS produced by this procedure
• 04_failures.txt contains 1399 presentations where the interreduction step ran into a resource limit

Termination

Most rewriting systems generated by this procedure end up length-nonincreasing and hence terminating under shortlex ordering. Because these are of limited interest, they are placed into a separate file.

The 2037 non-shortlex string rewriting systems range from being straightforward to prove terminating, to apparently resisting everything matchbox can throw at it.

The earliest system whose termination could neither be established nor ruled out ranks fifth in 02_nontrivial.txt:

# < a,b | baabbaba=a >
baabbaba -> a
baabbaa -> aabbaba
baaba -> aabbababbaba
baaa -> aabbababbaa

Code

The seed rewriting systems are produced by the algorithm listed below. A Knuth-Bendix style interreduction step must be performed on the seed system to finalize the construction. This step can diverge, resulting in a failure due to resource exhaustion. A local confluence check should also be performed.

def make_seed(lhs : str) -> list[tuple[str, str]]:
    rules = []

    rules.append((lhs, "a"))
    for i in range(len(lhs) - 1, 0, -1):
        if lhs[i - 1] == "a":
            continue

        left = lhs[: i - 1] + "a"
        right = lhs[: i - 1] + lhs

        for r, l in rules:
            if right.startswith(r):
                right = right.replace(r, l, 1)
                break
        else:
            continue

        if left == right:
            continue

        rules.append((left, right))

    return rules

I currently do not have a good understanding of this algorithm or why it appears to produce locally confluent rewriting systems.

Misc

I was able to use a family of rewriting systems derived from this procedure to show that a certain family of monoids has FCRS.

02_nontrivial.txt

# < a,b | baababa=a >
baababa -> a
baabaa -> aababa
baaa -> aababababa

# < a,b | bababba=a >
bababba -> a
bababa -> ababba
baa -> ababbabba

# < a,b | baaababa=a >
baaababa -> a
baaabaa -> aaababa
baaaa -> aaababaababa

# < a,b | baababba=a >
baababba -> a
baababa -> aababba
baabaa -> aababa
baaa -> aababababba

# < a,b | baabbaba=a >
baabbaba -> a
baabbaa -> aabbaba
baaba -> aabbababbaba
baaa -> aabbababbaa

# < a,b | bababbba=a >
bababbba -> a
bababba -> ababbba
bababa -> ababba
baa -> ababbabbba

# < a,b | baaaababa=a >
baaaababa -> a
baaaabaa -> aaaababa
baaaaa -> aaaababaaababa

# < a,b | baaabaaba=a >
baaabaaba -> a
baaabaaa -> aaabaaba
baaaa -> aaabaababaaba

# < a,b | baaababba=a >
baaababba -> a
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababba

# < a,b | baaabbaba=a >
baaabbaba -> a
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbaba
baaaa -> aaabbabaabbaa

# < a,b | baabaabba=a >
baabaabba -> a
baabaaba -> aabaabba
baaa -> aabaabbaabba

# < a,b | baabababa=a >
baabababa -> a
baababaa -> aabababa
baabaa -> aababababababa
baaa -> aabababababababababa

# < a,b | baababbba=a >
baababbba -> a
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbba

# < a,b | baabbabba=a >
baabbabba -> a
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabba
baaa -> aabbababbaba

# < a,b | babababba=a >
babababba -> a
babababa -> abababba
baa -> abababbabba

# < a,b | bababbbba=a >
bababbbba -> a
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbba

# < a,b | babbabbba=a >
babbabbba -> a
babbabba -> abbabbba
baba -> abbabbbabbba
baa -> abbabbbabba

# < a,b | baaaaababa=a >
baaaaababa -> a
baaaaabaa -> aaaaababa
baaaaaa -> aaaaababaaaababa

# < a,b | baaaabaaba=a >
baaaabaaba -> a
baaaabaaa -> aaaabaaba
baaaaa -> aaaabaabaabaaba

# < a,b | baaaababba=a >
baaaababba -> a
baaaababa -> aaaababba
baaaabaa -> aaaababa
baaaaa -> aaaababaaababba

# < a,b | baaaabbaba=a >
baaaabbaba -> a
baaaabbaa -> aaaabbaba
baaaaba -> aaaabbabaaabbaba
baaaaa -> aaaabbabaaabbaa

# < a,b | baaabaabaa=a >
baaabaabaa -> a
baaabaaa -> aabaabaa
baaaa -> aabaabaabaabaa

# < a,b | baaabaabba=a >
baaabaabba -> a
baaabaaba -> aaabaabba
baaabaaa -> aaabaaba
baaaa -> aaabaababaabba

# < a,b | baaabababa=a >
baaabababa -> a
baaababaa -> aaabababa
baaabaa -> aaabababaabababa
baaaa -> aaabababaabababaabababa

# < a,b | baaababbba=a >
baaababbba -> a
baaababba -> aaababbba
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababbba

# < a,b | baaabbaaba=a >
baaabbaaba -> a
baaabbaaa -> aaabbaaba
baaaba -> aaabbaababbaaba
baaaa -> aaabbaababbaaa

# < a,b | baaabbabba=a >
baaabbabba -> a
baaabbaba -> aaabbabba
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbabba
baaaa -> aaabbabaabbaba

# < a,b | baabaababa=a >
baabaababa -> a
baabaabaa -> aabaababa
baaa -> aabaababababa

# < a,b | baabaabbba=a >
baabaabbba -> a
baabaabba -> aabaabbba
baabaaba -> aabaabba
baaa -> aabaabbaabbba

# < a,b | baababaaba=a >
baababaaba -> a
baabaa -> abaaba
baaa -> abaabababaaba

# < a,b | baabababba=a >
baabababba -> a
baabababa -> aabababba
baababaa -> aabababa
baabaa -> aababababababba
baaa -> aababababababbabababba

# < a,b | baababbaba=a >
baababbaba -> a
baababbaa -> aababbaba
baababa -> aababbabababbaba
baabaa -> aababbabababbaa
baaa -> aababbabababa

# < a,b | baababbbba=a >
baababbbba -> a
baababbba -> aababbbba
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbbba

# < a,b | baabbababa=a >
baabbababa -> a
baabbabaa -> aabbababa
baabbaa -> aabbabababbababa
baaba -> aabbabababbabababbababa
baaa -> aabbabababbabababbabaa

# < a,b | baabbabbba=a >
baabbabbba -> a
baabbabba -> aabbabbba
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabbba
baaa -> aabbababbabba

# < a,b | baabbbabba=a >
baabbbabba -> a
baabbbaba -> aabbbabba
baabbbaa -> aabbbaba
baabba -> aabbbababbbabba
baaba -> aabbbababbbaba
baaa -> aabbbababbbaa

# < a,b | babaababba=a >
babaababba -> a
babaababa -> abaababba
babaabaa -> abaababa
babaaa -> abaababbaababba

# < a,b | babababbba=a >
babababbba -> a
babababba -> abababbba
babababa -> abababba
baa -> abababbabbba

# < a,b | bababbabba=a >
bababbabba -> a
bababbaba -> ababbabba
bababa -> ababbabbabbabba
baa -> ababbabbabbabbabbabba

# < a,b | bababbbbba=a >
bababbbbba -> a
bababbbba -> ababbbbba
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbbba

# < a,b | babbabbbba=a >
babbabbbba -> a
babbabbba -> abbabbbba
babbabba -> abbabbba
baba -> abbabbbabbbba
baa -> abbabbbabbba

# < a,b | bbaabbabba=a >
bbaabbabba -> a
bbaabbaa -> aabbabba
bbaaa -> aabbabbabbabba

# < a,b | baaaaaababa=a >
baaaaaababa -> a
baaaaaabaa -> aaaaaababa
baaaaaaa -> aaaaaababaaaaababa

# < a,b | baaaaabaaba=a >
baaaaabaaba -> a
baaaaabaaa -> aaaaabaaba
baaaaaa -> aaaaabaabaaabaaba

# < a,b | baaaaababba=a >
baaaaababba -> a
baaaaababa -> aaaaababba
baaaaabaa -> aaaaababa
baaaaaa -> aaaaababaaaababba

# < a,b | baaaaabbaba=a >
baaaaabbaba -> a
baaaaabbaa -> aaaaabbaba
baaaaaba -> aaaaabbabaaaabbaba
baaaaaa -> aaaaabbabaaaabbaa

# < a,b | baaaabaaaba=a >
baaaabaaaba -> a
baaaabaaaa -> aaaabaaaba
baaaaa -> aaaabaaababaaaba

# < a,b | baaaabaabaa=a >
baaaabaabaa -> a
baaaabaaa -> aaabaabaa
baaaaa -> aaabaabaaabaabaa

# < a,b | baaaabaabba=a >
baaaabaabba -> a
baaaabaaba -> aaaabaabba
baaaabaaa -> aaaabaaba
baaaaa -> aaaabaabaabaabba

# < a,b | baaaabababa=a >
baaaabababa -> a
baaaababaa -> aaaabababa
baaaabaa -> aaaabababaaabababa
baaaaa -> aaaabababaaabababaaabababa

# < a,b | baaaababbba=a >
baaaababbba -> a
baaaababba -> aaaababbba
baaaababa -> aaaababba
baaaabaa -> aaaababa
baaaaa -> aaaababaaababbba

# < a,b | baaaabbaaba=a >
baaaabbaaba -> a
baaaabbaaa -> aaaabbaaba
baaaaba -> aaaabbaabaabbaaba
baaaaa -> aaaabbaabaabbaaa

# < a,b | baaaabbabba=a >
baaaabbabba -> a
baaaabbaba -> aaaabbabba
baaaabbaa -> aaaabbaba
baaaaba -> aaaabbabaaabbabba
baaaaa -> aaaabbabaaabbaba

# < a,b | baaabaaabba=a >
baaabaaabba -> a
baaabaaaba -> aaabaaabba
baaaa -> aaabaaabbaaabba

# < a,b | baaabaababa=a >
baaabaababa -> a
baaabaabaa -> aaabaababa
baaabaaa -> aaabaababaabaababa
baaaa -> aaabaababaabaabababaababa

# < a,b | baaabaabbba=a >
baaabaabbba -> a
baaabaabba -> aaabaabbba
baaabaaba -> aaabaabba
baaabaaa -> aaabaaba
baaaa -> aaabaababaabbba

# < a,b | baaababaaba=a >
baaababaaba -> a
baaababaaa -> aaababaaba
baaabaa -> aaababaabababaaba
baaaa -> aaababaabababaabaababaaba

# < a,b | baaabababba=a >
baaabababba -> a
baaabababa -> aaabababba
baaababaa -> aaabababa
baaabaa -> aaabababaabababba
baaaa -> aaabababaabababbaabababba

# < a,b | baaababbaba=a >
baaababbaba -> a
baaababbaa -> aaababbaba
baaababa -> aaababbabaababbaba
baaabaa -> aaababbabaababbaa
baaaa -> aaababbabaababa

# < a,b | baaababbbba=a >
baaababbbba -> a
baaababbba -> aaababbbba
baaababba -> aaababbba
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababbbba

# < a,b | baaabbaabba=a >
baaabbaabba -> a
baaabbaaba -> aaabbaabba
baaabbaaa -> aaabbaaba
baaaba -> aaabbaababbaabba
baaaa -> aaabbaababbaaba

# < a,b | baaabbababa=a >
baaabbababa -> a
baaabbabaa -> aaabbababa
baaabbaa -> aaabbababaabbababa
baaaba -> aaabbababaabbababaabbababa
baaaa -> aaabbababaabbababaabbabaa

# < a,b | baaabbabbba=a >
baaabbabbba -> a
baaabbabba -> aaabbabbba
baaabbaba -> aaabbabba
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbabbba
baaaa -> aaabbabaabbabba

# < a,b | baaabbbabba=a >
baaabbbabba -> a
baaabbbaba -> aaabbbabba
baaabbbaa -> aaabbbaba
baaabba -> aaabbbabaabbbabba
baaaba -> aaabbbabaabbbaba
baaaa -> aaabbbabaabbbaa

# < a,b | baabaaababa=a >
baabaaababa -> a
baabaaabaa -> aabaaababa
baabaaaa -> aabaaabababaaababa

# < a,b | baabaaabbaa=a >
baabaaabbaa -> a
baabaaaba -> abaaabbaa
baabaaaa -> abaaabbaaabaaabbaa

# < a,b | baabaababaa=a >
baabaababaa -> a
baabaabaa -> abaababaa
baaa -> abaababaababaa

# < a,b | baabaababba=a >
baabaababba -> a
baabaababa -> aabaababba
baabaabaa -> aabaababa
baaa -> aabaababababba

# < a,b | baabaabbaba=a >
baabaabbaba -> a
baabaabbaa -> aabaabbaba
baabaaba -> aabaabbababaabbaba
baaa -> aabaabbababaabbabaabbaba

# < a,b | baabaabbbba=a >
baabaabbbba -> a
baabaabbba -> aabaabbbba
baabaabba -> aabaabbba
baabaaba -> aabaabba
baaa -> aabaabbaabbbba

# < a,b | baababaabba=a >
baababaabba -> a
baababaaba -> aababaabba
baabaa -> aababaabbabaabba
baaa -> aababaabbabaabbababaabba

# < a,b | baababababa=a >
baababababa -> a
baabababaa -> aababababa
baababaa -> aababababababababa
baabaa -> aababababababababababababa
baaa -> aababababababababababababababababa

# < a,b | baabababbba=a >
baabababbba -> a
baabababba -> aabababbba
baabababa -> aabababba
baababaa -> aabababa
baabaa -> aababababababbba
baaa -> aababababababbbabababbba

# < a,b | baababbabba=a >
baababbabba -> a
baababbaba -> aababbabba
baababbaa -> aababbaba
baababa -> aababbabababbabba
baabaa -> aababbabababbaba
baaa -> aababbabababbabababbabba

# < a,b | baababbbbba=a >
baababbbbba -> a
baababbbba -> aababbbbba
baababbba -> aababbbba
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbbbba

# < a,b | baabbaababa=a >
baabbaababa -> a
baabbaabaa -> aabbaababa
baabbaaa -> aabbaabababbaababa

# < a,b | baabbaabbba=a >
baabbaabbba -> a
baabbaabba -> aabbaabbba
baaba -> aabbaabbbaabbba
baaa -> aabbaabbbaabba

# < a,b | baabbababba=a >
baabbababba -> a
baabbababa -> aabbababba
baabbabaa -> aabbababa
baabbaa -> aabbabababbababba
baaba -> aabbabababbababbabbababba
baaa -> aabbabababbababbabbababa

# < a,b | baabbabbaba=a >
baabbabbaba -> a
baabbabbaa -> aabbabbaba
baabbaba -> aabbabbababbabbaba
baabbaa -> aabbabbababbabbaa
baaba -> aabbabbababbaba
baaa -> aabbabbababbaa

# < a,b | baabbabbbba=a >
baabbabbbba -> a
baabbabbba -> aabbabbbba
baabbabba -> aabbabbba
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabbbba
baaa -> aabbababbabbba

# < a,b | baabbbabbba=a >
baabbbabbba -> a
baabbbabba -> aabbbabbba
baabbbaba -> aabbbabba
baabbbaa -> aabbbaba
baabba -> aabbbababbbabbba
baaba -> aabbbababbbabba
baaa -> aabbbababbbaba

# < a,b | babaaababba=a >
babaaababba -> a
babaaababa -> abaaababba
babaaabaa -> abaaababa
babaaaa -> abaaababbaaababba

# < a,b | babaabababa=a >
babaabababa -> a
babaababaa -> abaabababa
babaabaa -> aabababa
babaaa -> abaababababababa

# < a,b | babaababbba=a >
babaababbba -> a
babaababba -> abaababbba
babaababa -> abaababba
babaabaa -> abaababa
babaaa -> abaababbaababbba

# < a,b | babaabbabba=a >
babaabbabba -> a
babaabbaba -> abaabbabba
babaabbaa -> abaabbaba
babaaba -> abaabbabbaabbabba
babaaa -> abaabbabbaabbaba

# < a,b | babaabbbaba=a >
babaabbbaba -> a
babaabbbaa -> abaabbbaba
babaabba -> aabbbaba
babaaba -> aabbbaa
babaaa -> aabbbaabaabbbaba

# < a,b | bababababba=a >
bababababba -> a
bababababa -> ababababba
baa -> ababababbabba

# < a,b | babababbaba=a >
babababbaba -> a
babababa -> ababbaba
baa -> ababbababbaba

# < a,b | babababbbba=a >
babababbbba -> a
babababbba -> abababbbba
babababba -> abababbba
babababa -> abababba
baa -> abababbabbbba

# < a,b | bababbabbba=a >
bababbabbba -> a
bababbabba -> ababbabbba
bababbaba -> ababbabba
bababa -> ababbabbabbabbba
baa -> ababbabbabbabbbabbabbba

# < a,b | bababbbabba=a >
bababbbabba -> a
bababbbaba -> ababbbabba
bababba -> ababbbabbabbbabba
bababa -> ababbbabbabbbaba
baa -> ababbbabbabba

# < a,b | bababbbbbba=a >
bababbbbbba -> a
bababbbbba -> ababbbbbba
bababbbba -> ababbbbba
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbbbba

# < a,b | babbababbba=a >
babbababbba -> a
babbababba -> abbababbba
babbababa -> abbababba
babbaa -> abbababbbababbba
babbabaa -> abbababa

# < a,b | babbabbbbba=a >
babbabbbbba -> a
babbabbbba -> abbabbbbba
babbabbba -> abbabbbba
babbabba -> abbabbba
baba -> abbabbbabbbbba
baa -> abbabbbabbbba

# < a,b | babbbabbbba=a >
babbbabbbba -> a
babbbabbba -> abbbabbbba
babba -> abbbabbbbabbbba
baba -> abbbabbbbabbba
baa -> ababbbbabbbba

# < a,b | bbaaabbabba=a >
bbaaabbabba -> a
bbaaabbaa -> aaabbabba
bbaaaa -> aaabbabbaabbabba

# < a,b | bbaabbbabba=a >
bbaabbbabba -> a
bbaabbbaa -> aabbbabba
bbaaba -> aabbbabbabbbabba

# < a,b | bbaabbbbbaa=a >
bbaabbbbbaa -> a
bbaabbba -> abbbbbaa
bbaaba -> abbbbbaaabbbbbaa

# < a,b | bbabbabbbba=a >
bbabbabbbba -> a
bbabbabba -> abbabbbba
bbaa -> abbabbbbabbbba

# < a,b | baaaaaaababa=a >
baaaaaaababa -> a
baaaaaaabaa -> aaaaaaababa
baaaaaaaa -> aaaaaaababaaaaaababa

# < a,b | baaaaaabaaba=a >
baaaaaabaaba -> a
baaaaaabaaa -> aaaaaabaaba
baaaaaaa -> aaaaaabaabaaaabaaba

# < a,b | baaaaaababba=a >
baaaaaababba -> a
baaaaaababa -> aaaaaababba
baaaaaabaa -> aaaaaababa
baaaaaaa -> aaaaaababaaaaababba

# < a,b | baaaaaabbaba=a >
baaaaaabbaba -> a
baaaaaabbaa -> aaaaaabbaba
baaaaaaba -> aaaaaabbabaaaaabbaba
baaaaaaa -> aaaaaabbabaaaaabbaa

# < a,b | baaaaabaaaba=a >
baaaaabaaaba -> a
baaaaabaaaa -> aaaaabaaaba
baaaaaa -> aaaaabaaabaabaaaba

# < a,b | baaaaabaabaa=a >
baaaaabaabaa -> a
baaaaabaaa -> aaaabaabaa
baaaaaa -> aaaabaabaaaabaabaa

# < a,b | baaaaabaabba=a >
baaaaabaabba -> a
baaaaabaaba -> aaaaabaabba
baaaaabaaa -> aaaaabaaba
baaaaaa -> aaaaabaabaaabaabba

# < a,b | baaaaabababa=a >
baaaaabababa -> a
baaaaababaa -> aaaaabababa
baaaaabaa -> aaaaabababaaaabababa
baaaaaa -> aaaaabababaaaabababaaaabababa

# < a,b | baaaaababbba=a >
baaaaababbba -> a
baaaaababba -> aaaaababbba
baaaaababa -> aaaaababba
baaaaabaa -> aaaaababa
baaaaaa -> aaaaababaaaababbba

# < a,b | baaaaabbaaba=a >
baaaaabbaaba -> a
baaaaabbaaa -> aaaaabbaaba
baaaaaba -> aaaaabbaabaaabbaaba
baaaaaa -> aaaaabbaabaaabbaaa

# < a,b | baaaaabbabba=a >
baaaaabbabba -> a
baaaaabbaba -> aaaaabbabba
baaaaabbaa -> aaaaabbaba
baaaaaba -> aaaaabbabaaaabbabba
baaaaaa -> aaaaabbabaaaabbaba

# < a,b | baaaabaaabaa=a >
baaaabaaabaa -> a
baaaabaaaa -> aaabaaabaa
baaaaa -> aaabaaabaabaaabaa

# < a,b | baaaabaaabba=a >
baaaabaaabba -> a
baaaabaaaba -> aaaabaaabba
baaaabaaaa -> aaaabaaaba
baaaaa -> aaaabaaababaaabba

# < a,b | baaaabaababa=a >
baaaabaababa -> a
baaaabaabaa -> aaaabaababa
baaaabaaa -> aaaabaababaaabaababa
baaaaa -> aaaabaababaaabaababaabaababa

# < a,b | baaaabaabbba=a >
baaaabaabbba -> a
baaaabaabba -> aaaabaabbba
baaaabaaba -> aaaabaabba
baaaabaaa -> aaaabaaba
baaaaa -> aaaabaabaabaabbba

# < a,b | baaaababaaba=a >
baaaababaaba -> a
baaaababaaa -> aaaababaaba
baaaabaa -> aaaababaabaababaaba
baaaaa -> aaaababaabaababaabaaababaaba

# < a,b | baaaabababba=a >
baaaabababba -> a
baaaabababa -> aaaabababba
baaaababaa -> aaaabababa
baaaabaa -> aaaabababaaabababba
baaaaa -> aaaabababaaabababbaaabababba

# < a,b | baaaababbaba=a >
baaaababbaba -> a
baaaababbaa -> aaaababbaba
baaaababa -> aaaababbabaaababbaba
baaaabaa -> aaaababbabaaababbaa
baaaaa -> aaaababbabaaababa

# < a,b | baaaababbbba=a >
baaaababbbba -> a
baaaababbba -> aaaababbbba
baaaababba -> aaaababbba
baaaababa -> aaaababba
baaaabaa -> aaaababa
baaaaa -> aaaababaaababbbba

# < a,b | baaaabbaaaba=a >
baaaabbaaaba -> a
baaaabbaaaa -> aaaabbaaaba
baaaaba -> aaaabbaaababbaaaba
baaaaa -> aaaabbaaababbaaaa

# < a,b | baaaabbaabba=a >
baaaabbaabba -> a
baaaabbaaba -> aaaabbaabba
baaaabbaaa -> aaaabbaaba
baaaaba -> aaaabbaabaabbaabba
baaaaa -> aaaabbaabaabbaaba

# < a,b | baaaabbababa=a >
baaaabbababa -> a
baaaabbabaa -> aaaabbababa
baaaabbaa -> aaaabbababaaabbababa
baaaaba -> aaaabbababaaabbababaaabbababa
baaaaa -> aaaabbababaaabbababaaabbabaa

# < a,b | baaaabbabbba=a >
baaaabbabbba -> a
baaaabbabba -> aaaabbabbba
baaaabbaba -> aaaabbabba
baaaabbaa -> aaaabbaba
baaaaba -> aaaabbabaaabbabbba
baaaaa -> aaaabbabaaabbabba

# < a,b | baaaabbbabba=a >
baaaabbbabba -> a
baaaabbbaba -> aaaabbbabba
baaaabbbaa -> aaaabbbaba
baaaabba -> aaaabbbabaaabbbabba
baaaaba -> aaaabbbabaaabbbaba
baaaaa -> aaaabbbabaaabbbaa

# < a,b | baaabaaababa=a >
baaabaaababa -> a
baaabaaabaa -> aaabaaababa
baaaa -> aaabaaababaababa

# < a,b | baaabaaabbba=a >
baaabaaabbba -> a
baaabaaabba -> aaabaaabbba
baaabaaaba -> aaabaaabba
baaaa -> aaabaaabbaaabbba

# < a,b | baaabaabaaba=a >
baaabaabaaba -> a
baaabaabaaa -> aaabaabaaba
baaabaaa -> aaabaabaababaabaaba
baaaa -> aaabaabaababaabaababaabaaba

# < a,b | baaabaababaa=a >
baaabaababaa -> a
baaabaabaa -> aabaababaa
baaabaaa -> aabaabaa
baaaa -> aabaabaabaababaa

# < a,b | baaabaababba=a >
baaabaababba -> a
baaabaababa -> aaabaababba
baaabaabaa -> aaabaababa
baaabaaa -> aaabaababaabaababba
baaaa -> aaabaababaabaababbabaababba

# < a,b | baaabaabbaba=a >
baaabaabbaba -> a
baaabaabbaa -> aaabaabbaba
baaabaaba -> aaabaabbabaabaabbaba
baaabaaa -> aaabaabbabaabaabbaa
baaaa -> aaabaabbabaabaabbaabaabbaba

# < a,b | baaabaabbbba=a >
baaabaabbbba -> a
baaabaabbba -> aaabaabbbba
baaabaabba -> aaabaabbba
baaabaaba -> aaabaabba
baaabaaa -> aaabaaba
baaaa -> aaabaababaabbbba

# < a,b | baaababaaaba=a >
baaababaaaba -> a
baaabaa -> abaaaba
baaaa -> aabaaabababaaaba

# < a,b | baaababaabaa=a >
baaababaabaa -> a
baaababaaa -> aababaabaa
baaabaa -> aababaabaababaabaa
baaaa -> aababaabaababaaa

# < a,b | baaababaabba=a >
baaababaabba -> a
baaababaaba -> aaababaabba
baaababaaa -> aaababaaba
baaabaa -> aaababaabababaabba
baaaa -> aaababaabababaabbaababaabba

# < a,b | baaababababa=a >
baaababababa -> a
baaabababaa -> aaababababa
baaababaa -> aaababababaababababa
baaabaa -> aaababababaababababaababababa
baaaa -> aaababababaababababaababababaababababa

# < a,b | baaabababbba=a >
baaabababbba -> a
baaabababba -> aaabababbba
baaabababa -> aaabababba
baaababaa -> aaabababa
baaabaa -> aaabababaabababbba
baaaa -> aaabababaabababbbaabababbba

# < a,b | baaababbabba=a >
baaababbabba -> a
baaababbaba -> aaababbabba
baaababbaa -> aaababbaba
baaababa -> aaababbabaababbabba
baaabaa -> aaababbabaababbaba
baaaa -> aaababbabaababbabaababbabba

# < a,b | baaababbbbba=a >
baaababbbbba -> a
baaababbbba -> aaababbbbba
baaababbba -> aaababbbba
baaababba -> aaababbba
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababbbbba

# < a,b | baaabbaababa=a >
baaabbaababa -> a
baaabbaabaa -> aaabbaababa
baaabbaaa -> aaabbaababaabbaababa
baaaba -> aaabbaababaabbaabababbaababa
baaaa -> aaabbaababaabbaabababbaabaa

# < a,b | baaabbaabbba=a >
baaabbaabbba -> a
baaabbaabba -> aaabbaabbba
baaabbaaba -> aaabbaabba
baaabbaaa -> aaabbaaba
baaaba -> aaabbaababbaabbba
baaaa -> aaabbaababbaabba

# < a,b | baaabbabaaba=a >
baaabbabaaba -> a
baaabbabaaa -> aaabbabaaba
baaabbaa -> aaabbabaababbabaaba
baaaba -> aaabbabaababbabaabaabbabaaba
baaaa -> aaabbabaababbabaabaabbabaaa

# < a,b | baaabbababba=a >
baaabbababba -> a
baaabbababa -> aaabbababba
baaabbabaa -> aaabbababa
baaabbaa -> aaabbababaabbababba
baaaba -> aaabbababaabbababbaabbababba
baaaa -> aaabbababaabbababbaabbababa

# < a,b | baaabbabbaba=a >
baaabbabbaba -> a
baaabbabbaa -> aaabbabbaba
baaabbaba -> aaabbabbabaabbabbaba
baaabbaa -> aaabbabbabaabbabbaa
baaaba -> aaabbabbabaabbaba
baaaa -> aaabbabbabaabbaa

# < a,b | baaabbabbbba=a >
baaabbabbbba -> a
baaabbabbba -> aaabbabbbba
baaabbabba -> aaabbabbba
baaabbaba -> aaabbabba
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbabbbba
baaaa -> aaabbabaabbabbba

# < a,b | baaabbbaabba=a >
baaabbbaabba -> a
baaabbbaaba -> aaabbbaabba
baaabbbaaa -> aaabbbaaba
baaabba -> aaabbbaababbbaabba
baaaba -> aaabbbaababbbaaba
baaaa -> aaabbbaababbbaaa

# < a,b | baaabbbabbba=a >
baaabbbabbba -> a
baaabbbabba -> aaabbbabbba
baaabbbaba -> aaabbbabba
baaabbbaa -> aaabbbaba
baaabba -> aaabbbabaabbbabbba
baaaba -> aaabbbabaabbbabba
baaaa -> aaabbbabaabbbaba

# < a,b | baabaaaababa=a >
baabaaaababa -> a
baabaaaabaa -> aabaaaababa
baabaaaaa -> aabaaaabababaaaababa

# < a,b | baabaaaabbaa=a >
baabaaaabbaa -> a
baabaaaaba -> abaaaabbaa
baabaaaaa -> abaaaabbaaabaaaabbaa

# < a,b | baabaaababba=a >
baabaaababba -> a
baabaaababa -> aabaaababba
baabaaabaa -> aabaaababa
baabaaaa -> aabaaabababaaababba

# < a,b | baabaaabbaba=a >
baabaaabbaba -> a
baabaaabbaa -> aabaaabbaba
baabaaaba -> aabaaabbababaaabbaba
baabaaaa -> aabaaabbababaaabbaa

# < a,b | baabaaabbbaa=a >
baabaaabbbaa -> a
baabaaabba -> abaaabbbaa
baabaaaba -> abaaabbbaaabaaabbbaa
baabaaaa -> abaaabbbaaabaaabbbaaabaaabbbaa

# < a,b | baabaabaabba=a >
baabaabaabba -> a
baabaabaaba -> aabaabaabba
baaa -> aabaabaabbaabba

# < a,b | baabaabababa=a >
baabaabababa -> a
baabaababaa -> aabaabababa
baabaabaa -> aabaababababaabababa
baaa -> aabaababababaababababababa

# < a,b | baabaababbba=a >
baabaababbba -> a
baabaababba -> aabaababbba
baabaababa -> aabaababba
baabaabaa -> aabaababa
baaa -> aabaababababbba

# < a,b | baabaabbabba=a >
baabaabbabba -> a
baabaabbaba -> aabaabbabba
baabaabbaa -> aabaabbaba
baabaaba -> aabaabbababaabbabba
baaa -> aabaabbababaabbabbaabbabba

# < a,b | baabaabbbbba=a >
baabaabbbbba -> a
baabaabbbba -> aabaabbbbba
baabaabbba -> aabaabbbba
baabaabba -> aabaabbba
baabaaba -> aabaabba
baaa -> aabaabbaabbbbba

# < a,b | baababaababa=a >
baababaababa -> a
baabaa -> aababa
baaa -> aababababaababa

# < a,b | baababaabbba=a >
baababaabbba -> a
baababaabba -> aababaabbba
baababaaba -> aababaabba
baabaa -> aababaabbabaabbba
baaa -> aababaabbabaabbbababaabbba

# < a,b | baabababaaba=a >
baabababaaba -> a
baababaa -> ababaaba
baabaa -> ababaababababaaba
baaa -> ababaababababaababababaaba

# < a,b | baababababba=a >
baababababba -> a
baababababa -> aababababba
baabababaa -> aababababa
baababaa -> aababababababababba
baabaa -> aababababababababbababababba
baaa -> aababababababababbababababbababababba

# < a,b | baabababbaba=a >
baabababbaba -> a
baabababbaa -> aabababbaba
baabababa -> aabababbababababbaba
baababaa -> aabababbababababbaa
baabaa -> aabababbababababa
baaa -> aabababbabababababababbaba

# < a,b | baabababbbba=a >
baabababbbba -> a
baabababbba -> aabababbbba
baabababba -> aabababbba
baabababa -> aabababba
baababaa -> aabababa
baabaa -> aababababababbbba
baaa -> aababababababbbbabababbbba

# < a,b | baababbaabba=a >
baababbaabba -> a
baababbaaba -> aababbaabba
baababa -> aababbaabbabbaabba
baabaa -> aababbaabbabbaaba
baaa -> aababbaabbaabbaabbabbaabba

# < a,b | baababbababa=a >
baababbababa -> a
baababbabaa -> aababbababa
baababbaa -> aababbababababbababa
baababa -> aababbababababbababababbababa
baabaa -> aababbababababbababababbabaa
baaa -> aababbababababbababababbaa

# < a,b | baababbabbba=a >
baababbabbba -> a
baababbabba -> aababbabbba
baababbaba -> aababbabba
baababbaa -> aababbaba
baababa -> aababbabababbabbba
baabaa -> aababbabababbabba
baaa -> aababbabababbabbababbabbba

# < a,b | baababbbabba=a >
baababbbabba -> a
baababbbaba -> aababbbabba
baababbbaa -> aababbbaba
baababba -> aababbbabababbbabba
baababa -> aababbbabababbbaba
baabaa -> aababbbabababbbaa
baaa -> aababbbabababba

# < a,b | baababbbbbba=a >
baababbbbbba -> a
baababbbbba -> aababbbbbba
baababbbba -> aababbbbba
baababbba -> aababbbba
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbbbbba

# < a,b | baabbaaababa=a >
baabbaaababa -> a
baabbaaabaa -> aabbaaababa
baabbaaaa -> aabbaaabababbaaababa

# < a,b | baabbaaabbaa=a >
baabbaaabbaa -> a
baabbaaaba -> abbaaabbaa
baabbaaaa -> abbaaabbaaabbaaabbaa

# < a,b | baabbaababba=a >
baabbaababba -> a
baabbaababa -> aabbaababba
baabbaabaa -> aabbaababa
baabbaaa -> aabbaabababbaababba

# < a,b | baabbaabbaba=a >
baabbaabbaba -> a
baabbaabbaa -> aabbaabbaba
baaba -> aabbaabbababbaba
baaa -> aabbaabbababbaa

# < a,b | baabbaabbbba=a >
baabbaabbbba -> a
baabbaabbba -> aabbaabbbba
baabbaabba -> aabbaabbba
baaba -> aabbaabbbaabbbba
baaa -> aabbaabbbaabbba

# < a,b | baabbabababa=a >
baabbabababa -> a
baabbababaa -> aabbabababa
baabbabaa -> aabbababababbabababa
baabbaa -> aabbababababbababababbabababa
baaba -> aabbababababbababababbababababbabababa
baaa -> aabbababababbababababbababababbababaa

# < a,b | baabbababbba=a >
baabbababbba -> a
baabbababba -> aabbababbba
baabbababa -> aabbababba
baabbabaa -> aabbababa
baabbaa -> aabbabababbababbba
baaba -> aabbabababbababbbabbababbba
baaa -> aabbabababbababbbabbababba

# < a,b | baabbabbabba=a >
baabbabbabba -> a
baabbabbaba -> aabbabbabba
baabbabbaa -> aabbabbaba
baabbaba -> aabbabbababbabbabba
baabbaa -> aabbabbababbabbaba
baaba -> aabbabbababbabbababbabbabba
baaa -> aabbabbababbabbababbabbaba

# < a,b | baabbabbbbba=a >
baabbabbbbba -> a
baabbabbbba -> aabbabbbbba
baabbabbba -> aabbabbbba
baabbabba -> aabbabbba
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabbbbba
baaa -> aabbababbabbbba

# < a,b | baabbbaababa=a >
baabbbaababa -> a
baabbbaabaa -> aabbbaababa
baabbbaaa -> aabbbaabababbbaababa

# < a,b | baabbbaabbaa=a >
baabbbaabbaa -> a
baabbbaaba -> abbbaabbaa
baabbbaaa -> abbbaabbaaabbbaabbaa

# < a,b | baabbbababba=a >
baabbbababba -> a
baabbbababa -> aabbbababba
baabbbabaa -> aabbbababa
baabbbaa -> aabbbabababbbababba
baabba -> aabbbabababbbababbabbbababba
baaba -> aabbbabababbbababbabbbababa
baaa -> aabbbabababbbababbabbbabaa

# < a,b | baabbbabbbba=a >
baabbbabbbba -> a
baabbbabbba -> aabbbabbbba
baabbbabba -> aabbbabbba
baabbbaba -> aabbbabba
baabbbaa -> aabbbaba
baabba -> aabbbababbbabbbba
baaba -> aabbbababbbabbba
baaa -> aabbbababbbabba

# < a,b | baabbbbabbba=a >
baabbbbabbba -> a
baabbbbabba -> aabbbbabbba
baabbbbaba -> aabbbbabba
baabbbbaa -> aabbbbaba
baabbba -> aabbbbababbbbabbba
baabba -> aabbbbababbbbabba
baaba -> aabbbbababbbbaba
baaa -> aabbbbababbbbaa

# < a,b | babaaaababba=a >
babaaaababba -> a
babaaaababa -> abaaaababba
babaaaabaa -> abaaaababa
babaaaaa -> abaaaababbaaaababba

# < a,b | babaaabababa=a >
babaaabababa -> a
babaaababaa -> abaaabababa
babaaabaa -> aaabababa
babaaaa -> abaaabababaabababa

# < a,b | babaaababbba=a >
babaaababbba -> a
babaaababba -> abaaababbba
babaaababa -> abaaababba
babaaabaa -> abaaababa
babaaaa -> abaaababbaaababbba

# < a,b | babaaabbabaa=a >
babaaabbabaa -> a
babaaaba -> aabbabaa
babaaaa -> aabbabaabaaabbabaa

# < a,b | babaaabbabba=a >
babaaabbabba -> a
babaaabbaba -> abaaabbabba
babaaabbaa -> abaaabbaba
babaaaba -> abaaabbabbaaabbabba
babaaaa -> abaaabbabbaaabbaba

# < a,b | babaaabbbaba=a >
babaaabbbaba -> a
babaaabbbaa -> abaaabbbaba
babaaabba -> aaabbbaba
babaaaba -> aaabbbaa
babaaaa -> aaabbbaabaaabbbaba

# < a,b | babaabababba=a >
babaabababba -> a
babaabababa -> abaabababba
babaababaa -> abaabababa
babaabaa -> abaabababbaabababba
babaaa -> abaababababababba

# < a,b | babaababbbba=a >
babaababbbba -> a
babaababbba -> abaababbbba
babaababba -> abaababbba
babaababa -> abaababba
babaabaa -> abaababa
babaaa -> abaababbaababbbba

# < a,b | babaabbababa=a >
babaabbababa -> a
babaabbabaa -> abaabbababa
babaabbaa -> aabbababa
babaaba -> abaabbabababbababa
babaaa -> abaabbabababbabaa

# < a,b | babaabbabbba=a >
babaabbabbba -> a
babaabbabba -> abaabbabbba
babaabbaba -> abaabbabba
babaabbaa -> abaabbaba
babaaba -> abaabbabbaabbabbba
babaaa -> abaabbabbaabbabba

# < a,b | babaabbbabba=a >
babaabbbabba -> a
babaabbbaba -> abaabbbabba
babaabbbaa -> abaabbbaba
babaabba -> abaabbbabbaabbbabba
babaaba -> abaabbbabbaabbbaba
babaaa -> abaabbbabbaabbbaa

# < a,b | babaabbbbaba=a >
babaabbbbaba -> a
babaabbbbaa -> abaabbbbaba
babaabbba -> aabbbbaba
babaabba -> aabbbbaa
babaaba -> aabbbbaabaabbbbaba
babaaa -> aabbbbaabaabbbbaa

# < a,b | bababaababba=a >
bababaababba -> a
bababaababa -> ababaababba
bababaabaa -> ababaababa
bababaaa -> ababaababbabaababba

# < a,b | bababababbba=a >
bababababbba -> a
bababababba -> ababababbba
bababababa -> ababababba
baa -> ababababbabbba

# < a,b | babababbabba=a >
babababbabba -> a
babababbaba -> abababbabba
babababa -> abababbabbababbabba
baa -> abababbabbababbabbabbabba

# < a,b | babababbbbba=a >
babababbbbba -> a
babababbbba -> abababbbbba
babababbba -> abababbbba
babababba -> abababbba
babababa -> abababba
baa -> abababbabbbbba

# < a,b | bababbababba=a >
bababbababba -> a
bababa -> ababba
baa -> ababbabbababba

# < a,b | bababbabbbba=a >
bababbabbbba -> a
bababbabbba -> ababbabbbba
bababbabba -> ababbabbba
bababbaba -> ababbabba
bababa -> ababbabbabbabbbba
baa -> ababbabbabbabbbbabbabbbba

# < a,b | bababbbabbba=a >
bababbbabbba -> a
bababbbabba -> ababbbabbba
bababbbaba -> ababbbabba
bababba -> ababbbabbabbbabbba
bababa -> ababbbabbabbbabba
baa -> ababbbabbabbbabbabbbabbba

# < a,b | bababbbbbbba=a >
bababbbbbbba -> a
bababbbbbba -> ababbbbbbba
bababbbbba -> ababbbbbba
bababbbba -> ababbbbba
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbbbbba

# < a,b | babbaababbba=a >
babbaababbba -> a
babbaababba -> abbaababbba
babbaababa -> abbaababba
babbaaa -> abbaababbbaababbba
babbaabaa -> abbaababa

# < a,b | babbababbbba=a >
babbababbbba -> a
babbababbba -> abbababbbba
babbababba -> abbababbba
babbababa -> abbababba
babbaa -> abbababbbababbbba
babbabaa -> abbababa

# < a,b | babbabbabbba=a >
babbabbabbba -> a
babbabbabba -> abbabbabbba
baba -> abbabbabbbabbba
baa -> abbabbabbbabba

# < a,b | babbabbbbbba=a >
babbabbbbbba -> a
babbabbbbba -> abbabbbbbba
babbabbbba -> abbabbbbba
babbabbba -> abbabbbba
babbabba -> abbabbba
baba -> abbabbbabbbbbba
baa -> abbabbbabbbbba

# < a,b | babbbabbbbba=a >
babbbabbbbba -> a
babbbabbbba -> abbbabbbbba
babbbabbba -> abbbabbbba
babba -> abbbabbbbabbbbba
baba -> abbbabbbbabbbba
baa -> abbbabbbbabbba

# < a,b | bbaaaabbabba=a >
bbaaaabbabba -> a
bbaaaabbaa -> aaaabbabba
bbaaaaa -> aaaabbabbaaabbabba

# < a,b | bbaaabbaabba=a >
bbaaabbaabba -> a
bbaaabbaaa -> aaabbaabba
bbaaaa -> aaabbaabbabbaabba

# < a,b | bbaaabbbabba=a >
bbaaabbbabba -> a
bbaaabbbaa -> aaabbbabba
bbaaaba -> aaabbbabbaabbbabba

# < a,b | bbaaabbbbbaa=a >
bbaaabbbbbaa -> a
bbaaabbba -> aabbbbbaa
bbaaaba -> aabbbbbaaaabbbbbaa

# < a,b | bbaababbabba=a >
bbaababbabba -> a
bbaababbaa -> aababbabba
bbaabaa -> aababbabbababbabba

# < a,b | bbaababbbbaa=a >
bbaababbbbaa -> a
bbaababba -> ababbbbaa
bbaabaa -> ababbbbaaababbbbaa

# < a,b | bbaabbabbbba=a >
bbaabbabbbba -> a
bbaabbabba -> aabbabbbba
bbaabbaa -> aabbabba
bbaaa -> aabbabbabbabbbba

# < a,b | bbaabbbbabba=a >
bbaabbbbabba -> a
bbaabbbbaa -> aabbbbabba
bbaabba -> aabbbbabbabbbbabba
bbaaa -> aabbbbabbabbbbaa

# < a,b | bbababbabbba=a >
bbababbabbba -> a
bbababbaba -> ababbabbba
bbabaa -> ababbabbbabbabbba

# < a,b | bbababbbbaba=a >
bbababbbbaba -> a
bbababba -> abbbbaba
bbabaa -> abbbbabababbbbaba

# < a,b | baaaaaaaababa=a >
baaaaaaaababa -> a
baaaaaaaabaa -> aaaaaaaababa
baaaaaaaaa -> aaaaaaaababaaaaaaababa

# < a,b | baaaaaaabaaba=a >
baaaaaaabaaba -> a
baaaaaaabaaa -> aaaaaaabaaba
baaaaaaaa -> aaaaaaabaabaaaaabaaba

# < a,b | baaaaaaababba=a >
baaaaaaababba -> a
baaaaaaababa -> aaaaaaababba
baaaaaaabaa -> aaaaaaababa
baaaaaaaa -> aaaaaaababaaaaaababba

# < a,b | baaaaaaabbaba=a >
baaaaaaabbaba -> a
baaaaaaabbaa -> aaaaaaabbaba
baaaaaaaba -> aaaaaaabbabaaaaaabbaba
baaaaaaaa -> aaaaaaabbabaaaaaabbaa

# < a,b | baaaaaabaaaba=a >
baaaaaabaaaba -> a
baaaaaabaaaa -> aaaaaabaaaba
baaaaaaa -> aaaaaabaaabaaabaaaba

# < a,b | baaaaaabaabaa=a >
baaaaaabaabaa -> a
baaaaaabaaa -> aaaaabaabaa
baaaaaaa -> aaaaabaabaaaaabaabaa

# < a,b | baaaaaabaabba=a >
baaaaaabaabba -> a
baaaaaabaaba -> aaaaaabaabba
baaaaaabaaa -> aaaaaabaaba
baaaaaaa -> aaaaaabaabaaaabaabba

# < a,b | baaaaaabababa=a >
baaaaaabababa -> a
baaaaaababaa -> aaaaaabababa
baaaaaabaa -> aaaaaabababaaaaabababa
baaaaaaa -> aaaaaabababaaaaabababaaaaabababa

# < a,b | baaaaaababbba=a >
baaaaaababbba -> a
baaaaaababba -> aaaaaababbba
baaaaaababa -> aaaaaababba
baaaaaabaa -> aaaaaababa
baaaaaaa -> aaaaaababaaaaababbba

# < a,b | baaaaaabbaaba=a >
baaaaaabbaaba -> a
baaaaaabbaaa -> aaaaaabbaaba
baaaaaaba -> aaaaaabbaabaaaabbaaba
baaaaaaa -> aaaaaabbaabaaaabbaaa

# < a,b | baaaaaabbabba=a >
baaaaaabbabba -> a
baaaaaabbaba -> aaaaaabbabba
baaaaaabbaa -> aaaaaabbaba
baaaaaaba -> aaaaaabbabaaaaabbabba
baaaaaaa -> aaaaaabbabaaaaabbaba

# < a,b | baaaaabaaaaba=a >
baaaaabaaaaba -> a
baaaaabaaaaa -> aaaaabaaaaba
baaaaaa -> aaaaabaaaababaaaaba

# < a,b | baaaaabaaabaa=a >
baaaaabaaabaa -> a
baaaaabaaaa -> aaaabaaabaa
baaaaaa -> aaaabaaabaaabaaabaa

# < a,b | baaaaabaaabba=a >
baaaaabaaabba -> a
baaaaabaaaba -> aaaaabaaabba
baaaaabaaaa -> aaaaabaaaba
baaaaaa -> aaaaabaaabaabaaabba

# < a,b | baaaaabaababa=a >
baaaaabaababa -> a
baaaaabaabaa -> aaaaabaababa
baaaaabaaa -> aaaaabaababaaaabaababa
baaaaaa -> aaaaabaababaaaabaababaaabaababa

# < a,b | baaaaabaabbba=a >
baaaaabaabbba -> a
baaaaabaabba -> aaaaabaabbba
baaaaabaaba -> aaaaabaabba
baaaaabaaa -> aaaaabaaba
baaaaaa -> aaaaabaabaaabaabbba

# < a,b | baaaaababaaba=a >
baaaaababaaba -> a
baaaaababaaa -> aaaaababaaba
baaaaabaa -> aaaaababaabaaababaaba
baaaaaa -> aaaaababaabaaababaabaaaababaaba

# < a,b | baaaaabababba=a >
baaaaabababba -> a
baaaaabababa -> aaaaabababba
baaaaababaa -> aaaaabababa
baaaaabaa -> aaaaabababaaaabababba
baaaaaa -> aaaaabababaaaabababbaaaabababba

# < a,b | baaaaababbaba=a >
baaaaababbaba -> a
baaaaababbaa -> aaaaababbaba
baaaaababa -> aaaaababbabaaaababbaba
baaaaabaa -> aaaaababbabaaaababbaa
baaaaaa -> aaaaababbabaaaababa

# < a,b | baaaaababbbba=a >
baaaaababbbba -> a
baaaaababbba -> aaaaababbbba
baaaaababba -> aaaaababbba
baaaaababa -> aaaaababba
baaaaabaa -> aaaaababa
baaaaaa -> aaaaababaaaababbbba

# < a,b | baaaaabbaaaba=a >
baaaaabbaaaba -> a
baaaaabbaaaa -> aaaaabbaaaba
baaaaaba -> aaaaabbaaabaabbaaaba
baaaaaa -> aaaaabbaaabaabbaaaa

# < a,b | baaaaabbaabba=a >
baaaaabbaabba -> a
baaaaabbaaba -> aaaaabbaabba
baaaaabbaaa -> aaaaabbaaba
baaaaaba -> aaaaabbaabaaabbaabba
baaaaaa -> aaaaabbaabaaabbaaba

# < a,b | baaaaabbababa=a >
baaaaabbababa -> a
baaaaabbabaa -> aaaaabbababa
baaaaabbaa -> aaaaabbababaaaabbababa
baaaaaba -> aaaaabbababaaaabbababaaaabbababa
baaaaaa -> aaaaabbababaaaabbababaaaabbabaa

# < a,b | baaaaabbabbba=a >
baaaaabbabbba -> a
baaaaabbabba -> aaaaabbabbba
baaaaabbaba -> aaaaabbabba
baaaaabbaa -> aaaaabbaba
baaaaaba -> aaaaabbabaaaabbabbba
baaaaaa -> aaaaabbabaaaabbabba

# < a,b | baaaaabbbabba=a >
baaaaabbbabba -> a
baaaaabbbaba -> aaaaabbbabba
baaaaabbbaa -> aaaaabbbaba
baaaaabba -> aaaaabbbabaaaabbbabba
baaaaaba -> aaaaabbbabaaaabbbaba
baaaaaa -> aaaaabbbabaaaabbbaa

# < a,b | baaaabaaaabba=a >
baaaabaaaabba -> a
baaaabaaaaba -> aaaabaaaabba
baaaaa -> aaaabaaaabbaaaabba

# < a,b | baaaabaaabaaa=a >
baaaabaaabaaa -> a
baaaabaaaa -> aabaaabaaa
baaaaa -> aabaaabaaabaaabaaa

# < a,b | baaaabaaababa=a >
baaaabaaababa -> a
baaaabaaabaa -> aaaabaaababa
baaaabaaaa -> aaaabaaababaaabaaababa
baaaaa -> aaaabaaababaaabaaabababaaababa

# < a,b | baaaabaaabbba=a >
baaaabaaabbba -> a
baaaabaaabba -> aaaabaaabbba
baaaabaaaba -> aaaabaaabba
baaaabaaaa -> aaaabaaaba
baaaaa -> aaaabaaababaaabbba

# < a,b | baaaabaabaaba=a >
baaaabaabaaba -> a
baaaabaabaaa -> aaaabaabaaba
baaaabaaa -> aaaabaabaabaabaabaaba
baaaaa -> aaaabaabaabaabaabaabaabaabaaba

# < a,b | baaaabaababaa=a >
baaaabaababaa -> a
baaaabaabaa -> aaabaababaa
baaaabaaa -> aaabaabaa
baaaaa -> aaabaabaaabaababaa

# < a,b | baaaabaababba=a >
baaaabaababba -> a
baaaabaababa -> aaaabaababba
baaaabaabaa -> aaaabaababa
baaaabaaa -> aaaabaababaaabaababba
baaaaa -> aaaabaababaaabaababbaabaababba

# < a,b | baaaabaabbaba=a >
baaaabaabbaba -> a
baaaabaabbaa -> aaaabaabbaba
baaaabaaba -> aaaabaabbabaaabaabbaba
baaaabaaa -> aaaabaabbabaaabaabbaa
baaaaa -> aaaabaabbabaaabaabbaaabaabbaba

# < a,b | baaaabaabbbba=a >
baaaabaabbbba -> a
baaaabaabbba -> aaaabaabbbba
baaaabaabba -> aaaabaabbba
baaaabaaba -> aaaabaabba
baaaabaaa -> aaaabaaba
baaaaa -> aaaabaabaabaabbbba

# < a,b | baaaababaaaba=a >
baaaababaaaba -> a
baaaababaaaa -> aaaababaaaba
baaaabaa -> aaaababaaabababaaaba
baaaaa -> aaaababaaabababaaabaaababaaaba

# < a,b | baaaababaabaa=a >
baaaababaabaa -> a
baaaababaaa -> aaababaabaa
baaaabaa -> aaababaabaaababaabaa
baaaaa -> aaababaabaaababaaa

# < a,b | baaaababaabba=a >
baaaababaabba -> a
baaaababaaba -> aaaababaabba
baaaababaaa -> aaaababaaba
baaaabaa -> aaaababaabaababaabba
baaaaa -> aaaababaabaababaabbaaababaabba

# < a,b | baaaababababa=a >
baaaababababa -> a
baaaabababaa -> aaaababababa
baaaababaa -> aaaababababaaababababa
baaaabaa -> aaaababababaaababababaaababababa
baaaaa -> aaaababababaaababababaaababababaaababababa

# < a,b | baaaabababbba=a >
baaaabababbba -> a
baaaabababba -> aaaabababbba
baaaabababa -> aaaabababba
baaaababaa -> aaaabababa
baaaabaa -> aaaabababaaabababbba
baaaaa -> aaaabababaaabababbbaaabababbba

# < a,b | baaaababbabba=a >
baaaababbabba -> a
baaaababbaba -> aaaababbabba
baaaababbaa -> aaaababbaba
baaaababa -> aaaababbabaaababbabba
baaaabaa -> aaaababbabaaababbaba
baaaaa -> aaaababbabaaababbabaaababbabba

# < a,b | baaaababbbbba=a >
baaaababbbbba -> a
baaaababbbba -> aaaababbbbba
baaaababbba -> aaaababbbba
baaaababba -> aaaababbba
baaaababa -> aaaababba
baaaabaa -> aaaababa
baaaaa -> aaaababaaababbbbba

# < a,b | baaaabbaaabba=a >
baaaabbaaabba -> a
baaaabbaaaba -> aaaabbaaabba
baaaabbaaaa -> aaaabbaaaba
baaaaba -> aaaabbaaababbaaabba
baaaaa -> aaaabbaaababbaaaba

# < a,b | baaaabbaababa=a >
baaaabbaababa -> a
baaaabbaabaa -> aaaabbaababa
baaaabbaaa -> aaaabbaababaaabbaababa
baaaaba -> aaaabbaababaaabbaababaabbaababa
baaaaa -> aaaabbaababaaabbaababaabbaabaa

# < a,b | baaaabbaabbba=a >
baaaabbaabbba -> a
baaaabbaabba -> aaaabbaabbba
baaaabbaaba -> aaaabbaabba
baaaabbaaa -> aaaabbaaba
baaaaba -> aaaabbaabaabbaabbba
baaaaa -> aaaabbaabaabbaabba

# < a,b | baaaabbabaaba=a >
baaaabbabaaba -> a
baaaabbabaaa -> aaaabbabaaba
baaaabbaa -> aaaabbabaabaabbabaaba
baaaaba -> aaaabbabaabaabbabaabaaabbabaaba
baaaaa -> aaaabbabaabaabbabaabaaabbabaaa

# < a,b | baaaabbababba=a >
baaaabbababba -> a
baaaabbababa -> aaaabbababba
baaaabbabaa -> aaaabbababa
baaaabbaa -> aaaabbababaaabbababba
baaaaba -> aaaabbababaaabbababbaaabbababba
baaaaa -> aaaabbababaaabbababbaaabbababa

# < a,b | baaaabbabbaba=a >
baaaabbabbaba -> a
baaaabbabbaa -> aaaabbabbaba
baaaabbaba -> aaaabbabbabaaabbabbaba
baaaabbaa -> aaaabbabbabaaabbabbaa
baaaaba -> aaaabbabbabaaabbaba
baaaaa -> aaaabbabbabaaabbaa

# < a,b | baaaabbabbbba=a >
baaaabbabbbba -> a
baaaabbabbba -> aaaabbabbbba
baaaabbabba -> aaaabbabbba
baaaabbaba -> aaaabbabba
baaaabbaa -> aaaabbaba
baaaaba -> aaaabbabaaabbabbbba
baaaaa -> aaaabbabaaabbabbba

# < a,b | baaaabbbaabba=a >
baaaabbbaabba -> a
baaaabbbaaba -> aaaabbbaabba
baaaabbbaaa -> aaaabbbaaba
baaaabba -> aaaabbbaabaabbbaabba
baaaaba -> aaaabbbaabaabbbaaba
baaaaa -> aaaabbbaabaabbbaaa

# < a,b | baaaabbbabbba=a >
baaaabbbabbba -> a
baaaabbbabba -> aaaabbbabbba
baaaabbbaba -> aaaabbbabba
baaaabbbaa -> aaaabbbaba
baaaabba -> aaaabbbabaaabbbabbba
baaaaba -> aaaabbbabaaabbbabba
baaaaa -> aaaabbbabaaabbbaba

# < a,b | baaabaaaababa=a >
baaabaaaababa -> a
baaabaaaabaa -> aaabaaaababa
baaabaaaaa -> aaabaaaababaabaaaababa

# < a,b | baaabaaaabbaa=a >
baaabaaaabbaa -> a
baaabaaaaba -> aabaaaabbaa
baaabaaaaa -> aabaaaabbaaaabaaaabbaa

# < a,b | baaabaaabaaba=a >
baaabaaabaaba -> a
baaabaaabaaa -> aaabaaabaaba
baaaa -> aaabaaabaababaaba

# < a,b | baaabaaababaa=a >
baaabaaababaa -> a
baaabaaabaa -> aabaaababaa
baaaa -> aabaaababaaababaa

# < a,b | baaabaaababba=a >
baaabaaababba -> a
baaabaaababa -> aaabaaababba
baaabaaabaa -> aaabaaababa
baaaa -> aaabaaababaababba

# < a,b | baaabaaabbaba=a >
baaabaaabbaba -> a
baaabaaabbaa -> aaabaaabbaba
baaabaaaba -> aaabaaabbabaabaaabbaba
baaaa -> aaabaaabbabaabaaabbabaaabbaba

# < a,b | baaabaaabbbba=a >
baaabaaabbbba -> a
baaabaaabbba -> aaabaaabbbba
baaabaaabba -> aaabaaabbba
baaabaaaba -> aaabaaabba
baaaa -> aaabaaabbaaabbbba

# < a,b | baaabaabaaaba=a >
baaabaabaaaba -> a
baaabaaa -> aabaaaba
baaaa -> aabaaababaabaaaba

# < a,b | baaabaabaabaa=a >
baaabaabaabaa -> a
baaabaabaaa -> aabaabaabaa
baaabaaa -> aabaabaabaabaabaabaa
baaaa -> aabaabaabaabaabaabaabaabaabaa

# < a,b | baaabaabaabba=a >
baaabaabaabba -> a
baaabaabaaba -> aaabaabaabba
baaabaabaaa -> aaabaabaaba
baaabaaa -> aaabaabaababaabaabba
baaaa -> aaabaabaababaabaabbabaabaabba

# < a,b | baaabaabababa=a >
baaabaabababa -> a
baaabaababaa -> aaabaabababa
baaabaabaa -> aaabaabababaabaabababa
baaabaaa -> aaabaabababaabaabababaabaabababa
baaaa -> aaabaabababaabaabababaabaababababaabababa

# < a,b | baaabaababbba=a >
baaabaababbba -> a
baaabaababba -> aaabaababbba
baaabaababa -> aaabaababba
baaabaabaa -> aaabaababa
baaabaaa -> aaabaababaabaababbba
baaaa -> aaabaababaabaababbbabaababbba

# < a,b | baaabaabbaaba=a >
baaabaabbaaba -> a
baaabaabbaaa -> aaabaabbaaba
baaabaaba -> aaabaabbaababaabbaaba
baaabaaa -> aaabaabbaababaabbaaa
baaaa -> aaabaabbaababaaba

# < a,b | baaabaabbabba=a >
baaabaabbabba -> a
baaabaabbaba -> aaabaabbabba
baaabaabbaa -> aaabaabbaba
baaabaaba -> aaabaabbabaabaabbabba
baaabaaa -> aaabaabbabaabaabbaba
baaaa -> aaabaabbabaabaabbababaabbabba

# < a,b | baaabaabbbbba=a >
baaabaabbbbba -> a
baaabaabbbba -> aaabaabbbbba
baaabaabbba -> aaabaabbbba
baaabaabba -> aaabaabbba
baaabaaba -> aaabaabba
baaabaaa -> aaabaaba
baaaa -> aaabaababaabbbbba

# < a,b | baaababaaabba=a >
baaababaaabba -> a
baaababaaaba -> aaababaaabba
baaabaa -> aaababaaabbabaaabba
baaaa -> aaababaaabbabaaabbaababaaabba

# < a,b | baaababaababa=a >
baaababaababa -> a
baaababaabaa -> aaababaababa
baaababaaa -> aaababaababaababaababa
baaabaa -> aaababaababaababaababababaababa
baaaa -> aaababaababaababaababababaababaababaababa

# < a,b | baaababaabbba=a >
baaababaabbba -> a
baaababaabba -> aaababaabbba
baaababaaba -> aaababaabba
baaababaaa -> aaababaaba
baaabaa -> aaababaabababaabbba
baaaa -> aaababaabababaabbbaababaabbba

# < a,b | baaabababaaba=a >
baaabababaaba -> a
baaabababaaa -> aaabababaaba
baaababaa -> aaabababaababababaaba
baaabaa -> aaabababaababababaabaabababaaba
baaaa -> aaabababaababababaabaabababaabaabababaaba

# < a,b | baaababababba=a >
baaababababba -> a
baaababababa -> aaababababba
baaabababaa -> aaababababa
baaababaa -> aaababababaababababba
baaabaa -> aaababababaababababbaababababba
baaaa -> aaababababaababababbaababababbaababababba

# < a,b | baaabababbaba=a >
baaabababbaba -> a
baaabababbaa -> aaabababbaba
baaabababa -> aaabababbabaabababbaba
baaababaa -> aaabababbabaabababbaa
baaabaa -> aaabababbabaabababa
baaaa -> aaabababbabaabababaabababbaba

# < a,b | baaabababbbba=a >
baaabababbbba -> a
baaabababbba -> aaabababbbba
baaabababba -> aaabababbba
baaabababa -> aaabababba
baaababaa -> aaabababa
baaabaa -> aaabababaabababbbba
baaaa -> aaabababaabababbbbaabababbbba

# < a,b | baaababbaabba=a >
baaababbaabba -> a
baaababbaaba -> aaababbaabba
baaababbaaa -> aaababbaaba
baaababa -> aaababbaabababbaabba
baaabaa -> aaababbaabababbaaba
baaaa -> aaababbaabababbaabaababbaabba

# < a,b | baaababbababa=a >
baaababbababa -> a
baaababbabaa -> aaababbababa
baaababbaa -> aaababbababaababbababa
baaababa -> aaababbababaababbababaababbababa
baaabaa -> aaababbababaababbababaababbabaa
baaaa -> aaababbababaababbababaababbaa

# < a,b | baaababbabbba=a >
baaababbabbba -> a
baaababbabba -> aaababbabbba
baaababbaba -> aaababbabba
baaababbaa -> aaababbaba
baaababa -> aaababbabaababbabbba
baaabaa -> aaababbabaababbabba
baaaa -> aaababbabaababbabbaababbabbba

# < a,b | baaababbbabba=a >
baaababbbabba -> a
baaababbbaba -> aaababbbabba
baaababbbaa -> aaababbbaba
baaababba -> aaababbbabaababbbabba
baaababa -> aaababbbabaababbbaba
baaabaa -> aaababbbabaababbbaa
baaaa -> aaababbbabaababba

# < a,b | baaababbbbbba=a >
baaababbbbbba -> a
baaababbbbba -> aaababbbbbba
baaababbbba -> aaababbbbba
baaababbba -> aaababbbba
baaababba -> aaababbba
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababbbbbba

# < a,b | baaabbaaababa=a >
baaabbaaababa -> a
baaabbaaabaa -> aaabbaaababa
baaabbaaaa -> aaabbaaababaabbaaababa

# < a,b | baaabbaaabbba=a >
baaabbaaabbba -> a
baaabbaaabba -> aaabbaaabbba
baaaba -> aaabbaaabbbaaabbba
baaaa -> aaabbaaabbbaaabba

# < a,b | baaabbaabaaba=a >
baaabbaabaaba -> a
baaabbaabaaa -> aaabbaabaaba
baaabbaaa -> aaabbaabaababbaabaaba
baaaba -> aaabbaabaababbaabaababbaabaaba
baaaa -> aaabbaabaababbaabaababbaabaaa

# < a,b | baaabbaababba=a >
baaabbaababba -> a
baaabbaababa -> aaabbaababba
baaabbaabaa -> aaabbaababa
baaabbaaa -> aaabbaababaabbaababba
baaaba -> aaabbaababaabbaababbabbaababba
baaaa -> aaabbaababaabbaababbabbaababa

# < a,b | baaabbaabbaba=a >
baaabbaabbaba -> a
baaabbaabbaa -> aaabbaabbaba
baaabbaaba -> aaabbaabbabaabbaabbaba
baaabbaaa -> aaabbaabbabaabbaabbaa
baaaba -> aaabbaabbabaabbaabbaabbaabbaba
baaaa -> aaabbaabbabaabbaabbaabbaabbaa

# < a,b | baaabbaabbbba=a >
baaabbaabbbba -> a
baaabbaabbba -> aaabbaabbbba
baaabbaabba -> aaabbaabbba
baaabbaaba -> aaabbaabba
baaabbaaa -> aaabbaaba
baaaba -> aaabbaababbaabbbba
baaaa -> aaabbaababbaabbba

# < a,b | baaabbabaabba=a >
baaabbabaabba -> a
baaabbabaaba -> aaabbabaabba
baaabbabaaa -> aaabbabaaba
baaabbaa -> aaabbabaababbabaabba
baaaba -> aaabbabaababbabaabbaabbabaabba
baaaa -> aaabbabaababbabaabbaabbabaaba

# < a,b | baaabbabababa=a >
baaabbabababa -> a
baaabbababaa -> aaabbabababa
baaabbabaa -> aaabbabababaabbabababa
baaabbaa -> aaabbabababaabbabababaabbabababa
baaaba -> aaabbabababaabbabababaabbabababaabbabababa
baaaa -> aaabbabababaabbabababaabbabababaabbababaa

# < a,b | baaabbababbba=a >
baaabbababbba -> a
baaabbababba -> aaabbababbba
baaabbababa -> aaabbababba
baaabbabaa -> aaabbababa
baaabbaa -> aaabbababaabbababbba
baaaba -> aaabbababaabbababbbaabbababbba
baaaa -> aaabbababaabbababbbaabbababba

# < a,b | baaabbabbabba=a >
baaabbabbabba -> a
baaabbabbaba -> aaabbabbabba
baaabbabbaa -> aaabbabbaba
baaabbaba -> aaabbabbabaabbabbabba
baaabbaa -> aaabbabbabaabbabbaba
baaaba -> aaabbabbabaabbabbabaabbabbabba
baaaa -> aaabbabbabaabbabbabaabbabbaba

# < a,b | baaabbabbbbba=a >
baaabbabbbbba -> a
baaabbabbbba -> aaabbabbbbba
baaabbabbba -> aaabbabbbba
baaabbabba -> aaabbabbba
baaabbaba -> aaabbabba
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbabbbbba
baaaa -> aaabbabaabbabbbba

# < a,b | baaabbbaabbba=a >
baaabbbaabbba -> a
baaabbbaabba -> aaabbbaabbba
baaabbbaaba -> aaabbbaabba
baaabbbaaa -> aaabbbaaba
baaabba -> aaabbbaababbbaabbba
baaaba -> aaabbbaababbbaabba
baaaa -> aaabbbaababbbaaba

# < a,b | baaabbbababba=a >
baaabbbababba -> a
baaabbbababa -> aaabbbababba
baaabbbabaa -> aaabbbababa
baaabbbaa -> aaabbbababaabbbababba
baaabba -> aaabbbababaabbbababbaabbbababba
baaaba -> aaabbbababaabbbababbaabbbababa
baaaa -> aaabbbababaabbbababbaabbbabaa

# < a,b | baaabbbabbbba=a >
baaabbbabbbba -> a
baaabbbabbba -> aaabbbabbbba
baaabbbabba -> aaabbbabbba
baaabbbaba -> aaabbbabba
baaabbbaa -> aaabbbaba
baaabba -> aaabbbabaabbbabbbba
baaaba -> aaabbbabaabbbabbba
baaaa -> aaabbbabaabbbabba

# < a,b | baaabbbbabbba=a >
baaabbbbabbba -> a
baaabbbbabba -> aaabbbbabbba
baaabbbbaba -> aaabbbbabba
baaabbbbaa -> aaabbbbaba
baaabbba -> aaabbbbabaabbbbabbba
baaabba -> aaabbbbabaabbbbabba
baaaba -> aaabbbbabaabbbbaba
baaaa -> aaabbbbabaabbbbaa

# < a,b | baabaaaaababa=a >
baabaaaaababa -> a
baabaaaaabaa -> aabaaaaababa
baabaaaaaa -> aabaaaaabababaaaaababa

# < a,b | baabaaaaabbaa=a >
baabaaaaabbaa -> a
baabaaaaaba -> abaaaaabbaa
baabaaaaaa -> abaaaaabbaaabaaaaabbaa

# < a,b | baabaaaababba=a >
baabaaaababba -> a
baabaaaababa -> aabaaaababba
baabaaaabaa -> aabaaaababa
baabaaaaa -> aabaaaabababaaaababba

# < a,b | baabaaaabbaba=a >
baabaaaabbaba -> a
baabaaaabbaa -> aabaaaabbaba
baabaaaaba -> aabaaaabbababaaaabbaba
baabaaaaa -> aabaaaabbababaaaabbaa

# < a,b | baabaaaabbbaa=a >
baabaaaabbbaa -> a
baabaaaabba -> abaaaabbbaa
baabaaaaba -> abaaaabbbaaabaaaabbbaa
baabaaaaa -> abaaaabbbaaabaaaabbbaaabaaaabbbaa

# < a,b | baabaaabaabba=a >
baabaaabaabba -> a
baabaaabaaba -> aabaaabaabba
baabaaabaaa -> aabaaabaaba
baabaaaa -> aabaaabaabbaaabaabba

# < a,b | baabaaabababa=a >
baabaaabababa -> a
baabaaababaa -> aabaaabababa
baabaaabaa -> aabaaababababaaabababa
baabaaaa -> aabaaababababaaababababaaabababa

# < a,b | baabaaababbaa=a >
baabaaababbaa -> a
baabaaababa -> abaaababbaa
baabaaabaa -> abaaababbaaabaaababbaa
baabaaaa -> abaaababbaaabaaababa

# < a,b | baabaaababbba=a >
baabaaababbba -> a
baabaaababba -> aabaaababbba
baabaaababa -> aabaaababba
baabaaabaa -> aabaaababa
baabaaaa -> aabaaabababaaababbba

# < a,b | baabaaabbabaa=a >
baabaaabbabaa -> a
baabaaabbaa -> abaaabbabaa
baabaaaba -> abaaabbaa
baabaaaa -> abaaabbaaabaaabbabaa

# < a,b | baabaaabbabba=a >
baabaaabbabba -> a
baabaaabbaba -> aabaaabbabba
baabaaabbaa -> aabaaabbaba
baabaaaba -> aabaaabbababaaabbabba
baabaaaa -> aabaaabbababaaabbaba

# < a,b | baabaaabbbaba=a >
baabaaabbbaba -> a
baabaaabbbaa -> aabaaabbbaba
baabaaabba -> aabaaabbbababaaabbbaba
baabaaaba -> aabaaabbbababaaabbbaa
baabaaaa -> aabaaabbbababaaabbbaaabaaabbbaba

# < a,b | baabaaabbbbaa=a >
baabaaabbbbaa -> a
baabaaabbba -> abaaabbbbaa
baabaaabba -> abaaabbbbaaabaaabbbbaa
baabaaaba -> abaaabbbbaaabaaabbbbaaabaaabbbbaa
baabaaaa -> abaaabbbbaaabaaabbbbaaabaaabbbbaaabaaabbbbaa

# < a,b | baabaabaababa=a >
baabaabaababa -> a
baabaabaabaa -> aabaabaababa
baaa -> aabaabaababababa

# < a,b | baabaabaabbba=a >
baabaabaabbba -> a
baabaabaabba -> aabaabaabbba
baabaabaaba -> aabaabaabba
baaa -> aabaabaabbaabbba

# < a,b | baabaababaaba=a >
baabaababaaba -> a
baabaabaa -> aababaaba
baaa -> aababaabababaaba

# < a,b | baabaabababaa=a >
baabaabababaa -> a
baabaababaa -> abaabababaa
baabaabaa -> abaababaa
baaa -> abaababaabababaa

# < a,b | baabaabababba=a >
baabaabababba -> a
baabaabababa -> aabaabababba
baabaababaa -> aabaabababa
baabaabaa -> aabaababababaabababba
baaa -> aabaababababaabababbabababba

# < a,b | baabaababbaba=a >
baabaababbaba -> a
baabaababbaa -> aabaababbaba
baabaababa -> aabaababbababaababbaba
baabaabaa -> aabaababbababaababbaa
baaa -> aabaababbababaababbaababbaba

# < a,b | baabaababbbba=a >
baabaababbbba -> a
baabaababbba -> aabaababbbba
baabaababba -> aabaababbba
baabaababa -> aabaababba
baabaabaa -> aabaababa
baaa -> aabaababababbbba

# < a,b | baabaabbaabba=a >
baabaabbaabba -> a
baabaabbaaba -> aabaabbaabba
baabaaba -> aabaabbaabbaabbaabba
baaa -> aabaabbaabbaabbaabbaabbaabba

# < a,b | baabaabbababa=a >
baabaabbababa -> a
baabaabbabaa -> aabaabbababa
baabaabbaa -> aabaabbabababaabbababa
baabaaba -> aabaabbabababaabbabababaabbababa
baaa -> aabaabbabababaabbabababaabbababaabbababa

# < a,b | baabaabbabbba=a >
baabaabbabbba -> a
baabaabbabba -> aabaabbabbba
baabaabbaba -> aabaabbabba
baabaabbaa -> aabaabbaba
baabaaba -> aabaabbababaabbabbba
baaa -> aabaabbababaabbabbbaabbabbba

# < a,b | baabaabbbabba=a >
baabaabbbabba -> a
baabaabbbaba -> aabaabbbabba
baabaabbbaa -> aabaabbbaba
baabaabba -> aabaabbbababaabbbabba
baabaaba -> aabaabbbababaabbbaba
baaa -> aabaabbbababaabbbabaabbbabba

# < a,b | baabaabbbbbba=a >
baabaabbbbbba -> a
baabaabbbbba -> aabaabbbbbba
baabaabbbba -> aabaabbbbba
baabaabbba -> aabaabbbba
baabaabba -> aabaabbba
baabaaba -> aabaabba
baaa -> aabaabbaabbbbbba

# < a,b | baababaaababa=a >
baababaaababa -> a
baababaaabaa -> aababaaababa
baababaaaa -> aababaaababababaaababa

# < a,b | baababaaabbaa=a >
baababaaabbaa -> a
baababaaaba -> ababaaabbaa
baababaaaa -> ababaaabbaaababaaabbaa

# < a,b | baababaababba=a >
baababaababba -> a
baababaababa -> aababaababba
baabaa -> aababaababbaababba
baaa -> aababaababbaababbababaababba

# < a,b | baababaabbaba=a >
baababaabbaba -> a
baababaabbaa -> aababaabbaba
baababaaba -> aababaabbabababaabbaba
baabaa -> aababaabbabababaabbababaabbaba
baaa -> aababaabbabababaabbababaabbabababaabbaba

# < a,b | baababaabbbba=a >
baababaabbbba -> a
baababaabbba -> aababaabbbba
baababaabba -> aababaabbba
baababaaba -> aababaabba
baabaa -> aababaabbabaabbbba
baaa -> aababaabbabaabbbbababaabbbba

# < a,b | baabababaabba=a >
baabababaabba -> a
baabababaaba -> aabababaabba
baababaa -> aabababaabbababaabba
baabaa -> aabababaabbababaabbabababaabba
baaa -> aabababaabbababaabbabababaabbabababaabba

# < a,b | baabababababa=a >
baabababababa -> a
baababababaa -> aabababababa
baabababaa -> aababababababababababa
baababaa -> aabababababababababababababababa
baabaa -> aababababababababababababababababababababa
baaa -> aabababababababababababababababababababababababababa

# < a,b | baababababbba=a >
baababababbba -> a
baababababba -> aababababbba
baababababa -> aababababba
baabababaa -> aababababa
baababaa -> aababababababababbba
baabaa -> aababababababababbbababababbba
baaa -> aababababababababbbababababbbababababbba

# < a,b | baabababbabba=a >
baabababbabba -> a
baabababbaba -> aabababbabba
baabababbaa -> aabababbaba
baabababa -> aabababbababababbabba
baababaa -> aabababbababababbaba
baabaa -> aabababbababababbababababbabba
baaa -> aabababbababababbababababbabbabababbabba

# < a,b | baabababbbbba=a >
baabababbbbba -> a
baabababbbba -> aabababbbbba
baabababbba -> aabababbbba
baabababba -> aabababbba
baabababa -> aabababba
baababaa -> aabababa
baabaa -> aababababababbbbba
baaa -> aababababababbbbbabababbbbba

# < a,b | baababbaababa=a >
baababbaababa -> a
baababbaabaa -> aababbaababa
baababbaaa -> aababbaababababbaababa

# < a,b | baababbaabbba=a >
baababbaabbba -> a
baababbaabba -> aababbaabbba
baababbaaba -> aababbaabba
baababa -> aababbaabbabbaabbba
baabaa -> aababbaabbabbaabba
baaa -> aababbaabbabbaabbababbaabbba

# < a,b | baababbababba=a >
baababbababba -> a
baababbababa -> aababbababba
baababbabaa -> aababbababa
baababbaa -> aababbababababbababba
baababa -> aababbababababbababbababbababba
baabaa -> aababbababababbababbababbababa
baaa -> aababbababababbababbababbababababbababba

# < a,b | baababbabbaba=a >
baababbabbaba -> a
baababbabbaa -> aababbabbaba
baababbaba -> aababbabbabababbabbaba
baababbaa -> aababbabbabababbabbaa
baababa -> aababbabbabababbaba
baabaa -> aababbabbabababbaa
baaa -> aababbabbabababa

# < a,b | baababbabbbba=a >
baababbabbbba -> a
baababbabbba -> aababbabbbba
baababbabba -> aababbabbba
baababbaba -> aababbabba
baababbaa -> aababbaba
baababa -> aababbabababbabbbba
baabaa -> aababbabababbabbba
baaa -> aababbabababbabbbababbabbbba

# < a,b | baababbbabbba=a >
baababbbabbba -> a
baababbbabba -> aababbbabbba
baababbbaba -> aababbbabba
baababbbaa -> aababbbaba
baababba -> aababbbabababbbabbba
baababa -> aababbbabababbbabba
baabaa -> aababbbabababbbaba
baaa -> aababbbabababbbabababbbabbba

# < a,b | baababbbbbbba=a >
baababbbbbbba -> a
baababbbbbba -> aababbbbbbba
baababbbbba -> aababbbbbba
baababbbba -> aababbbbba
baababbba -> aababbbba
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbbbbbba

# < a,b | baabbaaaababa=a >
baabbaaaababa -> a
baabbaaaabaa -> aabbaaaababa
baabbaaaaa -> aabbaaaabababbaaaababa

# < a,b | baabbaaaabbaa=a >
baabbaaaabbaa -> a
baabbaaaaba -> abbaaaabbaa
baabbaaaaa -> abbaaaabbaaabbaaaabbaa

# < a,b | baabbaaababba=a >
baabbaaababba -> a
baabbaaababa -> aabbaaababba
baabbaaabaa -> aabbaaababa
baabbaaaa -> aabbaaabababbaaababba

# < a,b | baabbaaabbaba=a >
baabbaaabbaba -> a
baabbaaabbaa -> aabbaaabbaba
baabbaaaba -> aabbaaabbababbaaabbaba
baabbaaaa -> aabbaaabbababbaaabbaa

# < a,b | baabbaaabbbaa=a >
baabbaaabbbaa -> a
baabbaaabba -> abbaaabbbaa
baabbaaaba -> abbaaabbbaaabbaaabbbaa
baabbaaaa -> abbaaabbbaaabbaaabbbaaabbaaabbbaa

# < a,b | baabbaabababa=a >
baabbaabababa -> a
baabbaababaa -> aabbaabababa
baabbaabaa -> aabbaababababbaabababa
baabbaaa -> aabbaababababbaababababbaabababa

# < a,b | baabbaababbaa=a >
baabbaababbaa -> a
baabbaababa -> abbaababbaa
baabbaabaa -> abbaababbaaabbaababbaa
baabbaaa -> abbaababbaaabbaababa

# < a,b | baabbaababbba=a >
baabbaababbba -> a
baabbaababba -> aabbaababbba
baabbaababa -> aabbaababba
baabbaabaa -> aabbaababa
baabbaaa -> aabbaabababbaababbba

# < a,b | baabbaabbabba=a >
baabbaabbabba -> a
baabbaabbaba -> aabbaabbabba
baabbaabbaa -> aabbaabbaba
baaba -> aabbaabbababbabba
baaa -> aabbaabbababbaba

# < a,b | baabbaabbbaba=a >
baabbaabbbaba -> a
baabbaabbbaa -> aabbaabbbaba
baabbaabba -> aabbaabbbababbaabbbaba
baaba -> aabbaabbbababbaabbbabaabbbaba
baaa -> aabbaabbbababbaabbbabaabbbaa

# < a,b | baabbaabbbbba=a >
baabbaabbbbba -> a
baabbaabbbba -> aabbaabbbbba
baabbaabbba -> aabbaabbbba
baabbaabba -> aabbaabbba
baaba -> aabbaabbbaabbbbba
baaa -> aabbaabbbaabbbba

# < a,b | baabbabaababa=a >
baabbabaababa -> a
baabbabaabaa -> aabbabaababa
baabbabaaa -> aabbabaabababbabaababa

# < a,b | baabbabaabbaa=a >
baabbabaabbaa -> a
baabbabaaba -> abbabaabbaa
baabbabaaa -> abbabaabbaaabbabaabbaa

# < a,b | baabbabaabbba=a >
baabbabaabbba -> a
baabbabaabba -> aabbabaabbba
baabbaa -> aabbabaabbbabaabbba
baaba -> aabbabaabbbabaabbbabbabaabbba
baaa -> aabbabaabbbabaabbbabbabaabba

# < a,b | baabbabababba=a >
baabbabababba -> a
baabbabababa -> aabbabababba
baabbababaa -> aabbabababa
baabbabaa -> aabbababababbabababba
baabbaa -> aabbababababbabababbabbabababba
baaba -> aabbababababbabababbabbabababbabbabababba
baaa -> aabbababababbabababbabbabababbabbabababa

# < a,b | baabbababbaba=a >
baabbababbaba -> a
baabbababbaa -> aabbababbaba
baabbababa -> aabbababbababbababbaba
baabbabaa -> aabbababbababbababbaa
baabbaa -> aabbababbababbababa
baaba -> aabbababbababbabababbababbaba
baaa -> aabbababbababbabababbababbaa

# < a,b | baabbababbbba=a >
baabbababbbba -> a
baabbababbba -> aabbababbbba
baabbababba -> aabbababbba
baabbababa -> aabbababba
baabbabaa -> aabbababa
baabbaa -> aabbabababbababbbba
baaba -> aabbabababbababbbbabbababbbba
baaa -> aabbabababbababbbbabbababbba

# < a,b | baabbabbabbba=a >
baabbabbabbba -> a
baabbabbabba -> aabbabbabbba
baabbabbaba -> aabbabbabba
baabbabbaa -> aabbabbaba
baabbaba -> aabbabbababbabbabbba
baabbaa -> aabbabbababbabbabba
baaba -> aabbabbababbabbabbabbabbabbba
baaa -> aabbabbababbabbabbabbabbabba

# < a,b | baabbabbbabba=a >
baabbabbbabba -> a
baabbabbbaba -> aabbabbbabba
baabbabbbaa -> aabbabbbaba
baabbabba -> aabbabbbababbabbbabba
baabbaba -> aabbabbbababbabbbaba
baabbaa -> aabbabbbababbabbbaa
baaba -> aabbabbbababbabba
baaa -> aabbabbbababbaba

# < a,b | baabbabbbbbba=a >
baabbabbbbbba -> a
baabbabbbbba -> aabbabbbbbba
baabbabbbba -> aabbabbbbba
baabbabbba -> aabbabbbba
baabbabba -> aabbabbba
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabbbbbba
baaa -> aabbababbabbbbba

# < a,b | baabbbaaababa=a >
baabbbaaababa -> a
baabbbaaabaa -> aabbbaaababa
baabbbaaaa -> aabbbaaabababbbaaababa

# < a,b | baabbbaaabbaa=a >
baabbbaaabbaa -> a
baabbbaaaba -> abbbaaabbaa
baabbbaaaa -> abbbaaabbaaabbbaaabbaa

# < a,b | baabbbaababba=a >
baabbbaababba -> a
baabbbaababa -> aabbbaababba
baabbbaabaa -> aabbbaababa
baabbbaaa -> aabbbaabababbbaababba

# < a,b | baabbbaabbaba=a >
baabbbaabbaba -> a
baabbbaabbaa -> aabbbaabbaba
baabbbaaba -> aabbbaabbababbbaabbaba
baabbbaaa -> aabbbaabbababbbaabbaa

# < a,b | baabbbaabbbba=a >
baabbbaabbbba -> a
baabbbaabbba -> aabbbaabbbba
baabba -> aabbbaabbbbaabbbba
baaba -> aabbbaabbbbaabbba
baaa -> aabaabbbbaabbbba

# < a,b | baabbbababbba=a >
baabbbababbba -> a
baabbbababba -> aabbbababbba
baabbbababa -> aabbbababba
baabbbabaa -> aabbbababa
baabbbaa -> aabbbabababbbababbba
baabba -> aabbbabababbbababbbabbbababbba
baaba -> aabbbabababbbababbbabbbababba
baaa -> aabbbabababbbababbbabbbababa

# < a,b | baabbbabbabba=a >
baabbbabbabba -> a
baabbbabbaba -> aabbbabbabba
baabbbabbaa -> aabbbabbaba
baabbbaba -> aabbbabbababbbabbabba
baabbbaa -> aabbbabbababbbabbaba
baabba -> aabbbabbababbbabbababbbabbabba
baaba -> aabbbabbababbbabbababbbabbaba
baaa -> aabbbabbababbbabbababbbabbaa

# < a,b | baabbbabbbbba=a >
baabbbabbbbba -> a
baabbbabbbba -> aabbbabbbbba
baabbbabbba -> aabbbabbbba
baabbbabba -> aabbbabbba
baabbbaba -> aabbbabba
baabbbaa -> aabbbaba
baabba -> aabbbababbbabbbbba
baaba -> aabbbababbbabbbba
baaa -> aabbbababbbabbba

# < a,b | baabbbbaababa=a >
baabbbbaababa -> a
baabbbbaabaa -> aabbbbaababa
baabbbbaaa -> aabbbbaabababbbbaababa

# < a,b | baabbbbaabbaa=a >
baabbbbaabbaa -> a
baabbbbaaba -> abbbbaabbaa
baabbbbaaa -> abbbbaabbaaabbbbaabbaa

# < a,b | baabbbbabbbba=a >
baabbbbabbbba -> a
baabbbbabbba -> aabbbbabbbba
baabbbbabba -> aabbbbabbba
baabbbbaba -> aabbbbabba
baabbbbaa -> aabbbbaba
baabbba -> aabbbbababbbbabbbba
baabba -> aabbbbababbbbabbba
baaba -> aabbbbababbbbabba
baaa -> aabbbbababbbbaba

# < a,b | babaaaaababba=a >
babaaaaababba -> a
babaaaaababa -> abaaaaababba
babaaaaabaa -> abaaaaababa
babaaaaaa -> abaaaaababbaaaaababba

# < a,b | babaaaabababa=a >
babaaaabababa -> a
babaaaababaa -> abaaaabababa
babaaaabaa -> aaaabababa
babaaaaa -> abaaaabababaaabababa

# < a,b | babaaaababbba=a >
babaaaababbba -> a
babaaaababba -> abaaaababbba
babaaaababa -> abaaaababba
babaaaabaa -> abaaaababa
babaaaaa -> abaaaababbaaaababbba

# < a,b | babaaaabbabaa=a >
babaaaabbabaa -> a
babaaaaba -> aaabbabaa
babaaaaa -> aaabbabaabaaaabbabaa

# < a,b | babaaaabbabba=a >
babaaaabbabba -> a
babaaaabbaba -> abaaaabbabba
babaaaabbaa -> abaaaabbaba
babaaaaba -> abaaaabbabbaaaabbabba
babaaaaa -> abaaaabbabbaaaabbaba

# < a,b | babaaaabbbaba=a >
babaaaabbbaba -> a
babaaaabbbaa -> abaaaabbbaba
babaaaabba -> aaaabbbaba
babaaaaba -> aaaabbbaa
babaaaaa -> aaaabbbaabaaaabbbaba

# < a,b | babaaababaaba=a >
babaaababaaba -> a
babaaababaaa -> abaaababaaba
babaaaa -> abaaababaabababaaba

# < a,b | babaaabababba=a >
babaaabababba -> a
babaaabababa -> abaaabababba
babaaababaa -> abaaabababa
babaaabaa -> abaaabababbaaabababba
babaaaa -> abaaabababaabababba

# < a,b | babaaababbbba=a >
babaaababbbba -> a
babaaababbba -> abaaababbbba
babaaababba -> abaaababbba
babaaababa -> abaaababba
babaaabaa -> abaaababa
babaaaa -> abaaababbaaababbbba

# < a,b | babaaabbababa=a >
babaaabbababa -> a
babaaabbabaa -> abaaabbababa
babaaabbaa -> aaabbababa
babaaaba -> abaaabbababaabbababa
babaaaa -> abaaabbababaabbabaa

# < a,b | babaaabbabbba=a >
babaaabbabbba -> a
babaaabbabba -> abaaabbabbba
babaaabbaba -> abaaabbabba
babaaabbaa -> abaaabbaba
babaaaba -> abaaabbabbaaabbabbba
babaaaa -> abaaabbabbaaabbabba

# < a,b | babaaabbbabaa=a >
babaaabbbabaa -> a
babaaabba -> aabbbabaa
babaaaba -> aabbbabaabaaabbbabaa
babaaaa -> aabbbabaabaaabbbabaabaaabbbabaa

# < a,b | babaaabbbabba=a >
babaaabbbabba -> a
babaaabbbaba -> abaaabbbabba
babaaabbbaa -> abaaabbbaba
babaaabba -> abaaabbbabbaaabbbabba
babaaaba -> abaaabbbabbaaabbbaba
babaaaa -> abaaabbbabbaaabbbaa

# < a,b | babaaabbbbaba=a >
babaaabbbbaba -> a
babaaabbbbaa -> abaaabbbbaba
babaaabbba -> aaabbbbaba
babaaabba -> aaabbbbaa
babaaaba -> aaabbbbaabaaabbbbaba
babaaaa -> aaabbbbaabaaabbbbaa

# < a,b | babaabaababba=a >
babaabaababba -> a
babaabaababa -> abaabaababba
babaabaabaa -> abaabaababa
babaabaaa -> abaabaababbaabaababba

# < a,b | babaababaabba=a >
babaababaabba -> a
babaababaaba -> abaababaabba
babaaa -> abaababaabbabaabba

# < a,b | babaababababa=a >
babaababababa -> a
babaabababaa -> abaababababa
babaababaa -> aababababa
babaabaa -> abaababababababababa
babaaa -> aababababababababa

# < a,b | babaabababbba=a >
babaabababbba -> a
babaabababba -> abaabababbba
babaabababa -> abaabababba
babaababaa -> abaabababa
babaabaa -> abaabababbaabababbba
babaaa -> abaababababababbba

# < a,b | babaababbabba=a >
babaababbabba -> a
babaababbaba -> abaababbabba
babaababbaa -> abaababbaba
babaababa -> abaababbabbaababbabba
babaabaa -> abaababbabbaababbaba
babaaa -> abaababbabbaababbabbaababbabba

# < a,b | babaababbbaba=a >
babaababbbaba -> a
babaababbbaa -> abaababbbaba
babaababba -> aababbbaba
babaababa -> aababbbaa
babaabaa -> aababbbaabaababbbaba
babaaa -> aababbbaaababbbaba

# < a,b | babaababbbbba=a >
babaababbbbba -> a
babaababbbba -> abaababbbbba
babaababbba -> abaababbbba
babaababba -> abaababbba
babaababa -> abaababba
babaabaa -> abaababa
babaaa -> abaababbaababbbbba

# < a,b | babaabbababba=a >
babaabbababba -> a
babaabbababa -> abaabbababba
babaabbabaa -> abaabbababa
babaabbaa -> abaabbababbaabbababba
babaaba -> abaabbabababbababba
babaaa -> abaabbabababbababa

# < a,b | babaabbabbbba=a >
babaabbabbbba -> a
babaabbabbba -> abaabbabbbba
babaabbabba -> abaabbabbba
babaabbaba -> abaabbabba
babaabbaa -> abaabbaba
babaaba -> abaabbabbaabbabbbba
babaaa -> abaabbabbaabbabbba

# < a,b | babaabbbabbba=a >
babaabbbabbba -> a
babaabbbabba -> abaabbbabbba
babaabbbaba -> abaabbbabba
babaabbbaa -> abaabbbaba
babaabba -> abaabbbabbaabbbabbba
babaaba -> abaabbbabbaabbbabba
babaaa -> abaabbbabbaabbbaba

# < a,b | babaabbbbabba=a >
babaabbbbabba -> a
babaabbbbaba -> abaabbbbabba
babaabbbbaa -> abaabbbbaba
babaabbba -> abaabbbbabbaabbbbabba
babaabba -> abaabbbbabbaabbbbaba
babaaba -> abaabbbbabbaabbbbaa
babaaa -> abaabbbbabbaabbbbaabaabbbbabba

# < a,b | babaabbbbbaba=a >
babaabbbbbaba -> a
babaabbbbbaa -> abaabbbbbaba
babaabbbba -> aabbbbbaba
babaabbba -> aabbbbbaa
babaabba -> aabbbbbaabaabbbbbaba
babaaba -> aabbbbbaabaabbbbbaa
babaaa -> aabbbbbaabaabbbbbaabaabbbbbaba

# < a,b | bababaaababba=a >
bababaaababba -> a
bababaaababa -> ababaaababba
bababaaabaa -> ababaaababa
bababaaaa -> ababaaababbabaaababba

# < a,b | bababaababbba=a >
bababaababbba -> a
bababaababba -> ababaababbba
bababaababa -> ababaababba
bababaabaa -> ababaababa
bababaaa -> ababaababbabaababbba

# < a,b | bababaabbabba=a >
bababaabbabba -> a
bababaabbaba -> ababaabbabba
bababaabbaa -> ababaabbaba
bababaaba -> ababaabbabbabaabbabba
bababaaa -> ababaabbabbabaabbaba

# < a,b | bababaabbbaba=a >
bababaabbbaba -> a
bababaabbbaa -> ababaabbbaba
bababaabba -> abaabbbaba
bababaaba -> abaabbbaa
bababaaa -> abaabbbaababaabbbaba

# < a,b | babababababba=a >
babababababba -> a
babababababa -> abababababba
baa -> abababababbabba

# < a,b | bababababbaba=a >
bababababbaba -> a
bababababa -> abababbaba
baa -> abababbababbaba

# < a,b | bababababbbba=a >
bababababbbba -> a
bababababbba -> ababababbbba
bababababba -> ababababbba
bababababa -> ababababba
baa -> ababababbabbbba

# < a,b | babababbabbba=a >
babababbabbba -> a
babababbabba -> abababbabbba
babababbaba -> abababbabba
babababa -> abababbabbababbabbba
baa -> abababbabbababbabbbabbabbba

# < a,b | babababbbabba=a >
babababbbabba -> a
babababbbaba -> abababbbabba
babababba -> abababbbabbababbbabba
babababa -> abababbbabbababbbaba
baa -> abababbbabbababbbababbbabba

# < a,b | babababbbbbba=a >
babababbbbbba -> a
babababbbbba -> abababbbbbba
babababbbba -> abababbbbba
babababbba -> abababbbba
babababba -> abababbba
babababa -> abababba
baa -> abababbabbbbbba

# < a,b | bababbaababba=a >
bababbaababba -> a
bababbaababa -> ababbaababba
bababbaabaa -> ababbaababa
bababbaaa -> ababbaababbabbaababba

# < a,b | bababbababbba=a >
bababbababbba -> a
bababbababba -> ababbababbba
bababa -> ababbababbbababbba
baa -> ababbababbbababbbabbababbba

# < a,b | bababbabbabba=a >
bababbabbabba -> a
bababbabbaba -> ababbabbabba
bababbaba -> ababbabbabbabbabbabba
bababa -> ababbabbabbabbabbabbabbabbabba
baa -> ababbabbabbabbabbabbabbabbabbabbabbabba

# < a,b | bababbabbbbba=a >
bababbabbbbba -> a
bababbabbbba -> ababbabbbbba
bababbabbba -> ababbabbbba
bababbabba -> ababbabbba
bababbaba -> ababbabba
bababa -> ababbabbabbabbbbba
baa -> ababbabbabbabbbbbabbabbbbba

# < a,b | bababbbababba=a >
bababbbababba -> a
bababbbababa -> ababbbababba
bababbbabaa -> ababbbababa
bababbbaa -> ababbbababbabbbababba

# < a,b | bababbbabbbba=a >
bababbbabbbba -> a
bababbbabbba -> ababbbabbbba
bababbbabba -> ababbbabbba
bababbbaba -> ababbbabba
bababba -> ababbbabbabbbabbbba
bababa -> ababbbabbabbbabbba
baa -> ababbbabbabbbabbbabbbabbbba

# < a,b | bababbbbabbba=a >
bababbbbabbba -> a
bababbbbabba -> ababbbbabbba
bababbbbaba -> ababbbbabba
bababbba -> ababbbbabbabbbbabbba
bababba -> ababbbbabbabbbbabba
bababa -> ababbbbabbabbbbaba
baa -> ababbbbabbabbba

# < a,b | bababbbbbbbba=a >
bababbbbbbbba -> a
bababbbbbbba -> ababbbbbbbba
bababbbbbba -> ababbbbbbba
bababbbbba -> ababbbbbba
bababbbba -> ababbbbba
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbbbbbba

# < a,b | babbaaababbba=a >
babbaaababbba -> a
babbaaababba -> abbaaababbba
babbaaababa -> abbaaababba
babbaaaa -> abbaaababbbaaababbba
babbaaabaa -> abbaaababa

# < a,b | babbaababbaba=a >
babbaababbaba -> a
babbaababbaa -> abbaababbaba
babbaaa -> abbaababbabababbaba

# < a,b | babbaababbbba=a >
babbaababbbba -> a
babbaababbba -> abbaababbbba
babbaababba -> abbaababbba
babbaababa -> abbaababba
babbaaa -> abbaababbbaababbbba
babbaabaa -> abbaababa

# < a,b | babbaabbabbaa=a >
babbaabbabbaa -> a
babbaaba -> abbabbaa
babbaaa -> abbabbaabbaabbabbaa

# < a,b | babbaabbabbba=a >
babbaabbabbba -> a
babbaabbabba -> abbaabbabbba
babbaabbaba -> abbaabbabba
babbaaba -> abbaabbabbbaabbabbba
babbaabbaa -> abbaabbaba
babbaaa -> abbaabbabbbaabbabba

# < a,b | babbabababbba=a >
babbabababbba -> a
babbabababba -> abbabababbba
babbabababa -> abbabababba
babbabaa -> abbabababbbabababbba
babbababaa -> abbabababa

# < a,b | babbababbabba=a >
babbababbabba -> a
babbababbaba -> abbababbabba
babbababa -> ababbabba
babbaa -> abbababbabbabbabba
babbabaa -> ababbaba

# < a,b | babbababbbbba=a >
babbababbbbba -> a
babbababbbba -> abbababbbbba
babbababbba -> abbababbbba
babbababba -> abbababbba
babbababa -> abbababba
babbaa -> abbababbbababbbbba
babbabaa -> abbababa

# < a,b | babbabbabbbba=a >
babbabbabbbba -> a
babbabbabbba -> abbabbabbbba
babbabbabba -> abbabbabbba
baba -> abbabbabbbabbbba
baa -> abbabbabbbabbba

# < a,b | babbabbbabbba=a >
babbabbbabbba -> a
babbabbbabba -> abbabbbabbba
babbabba -> abbabbbabbbabbbabbba
baba -> abbabbbabbbabbbabbbabbbabbba
baa -> abbabbbabbbabbbabbbabbbabba

# < a,b | babbabbbbbbba=a >
babbabbbbbbba -> a
babbabbbbbba -> abbabbbbbbba
babbabbbbba -> abbabbbbbba
babbabbbba -> abbabbbbba
babbabbba -> abbabbbba
babbabba -> abbabbba
baba -> abbabbbabbbbbbba
baa -> abbabbbabbbbbba

# < a,b | babbbababbbba=a >
babbbababbbba -> a
babbbababbba -> abbbababbbba
babbbababba -> abbbababbba
babbbaa -> abbbababbbbababbbba
babbbababa -> abbbababba
babbbabaa -> abbbababa

# < a,b | babbbabbbbbba=a >
babbbabbbbbba -> a
babbbabbbbba -> abbbabbbbbba
babbbabbbba -> abbbabbbbba
babbbabbba -> abbbabbbba
babba -> abbbabbbbabbbbbba
baba -> abbbabbbbabbbbba
baa -> abbbabbbbabbbba

# < a,b | babbbbabbbbba=a >
babbbbabbbbba -> a
babbbbabbbba -> abbbbabbbbba
babbba -> abbbbabbbbbabbbbba
babba -> abbbbabbbbbabbbba
baba -> abbabbbbbabbbbba
baa -> abbabbbbbabbbba

# < a,b | bbaaaaabbabba=a >
bbaaaaabbabba -> a
bbaaaaabbaa -> aaaaabbabba
bbaaaaaa -> aaaaabbabbaaaabbabba

# < a,b | bbaaaabbaabba=a >
bbaaaabbaabba -> a
bbaaaabbaaa -> aaaabbaabba
bbaaaaa -> aaaabbaabbaabbaabba

# < a,b | bbaaaabbbabba=a >
bbaaaabbbabba -> a
bbaaaabbbaa -> aaaabbbabba
bbaaaaba -> aaaabbbabbaaabbbabba

# < a,b | bbaaaabbbbbaa=a >
bbaaaabbbbbaa -> a
bbaaaabbba -> aaabbbbbaa
bbaaaaba -> aaabbbbbaaaaabbbbbaa

# < a,b | bbaaababbabba=a >
bbaaababbabba -> a
bbaaababbaa -> aaababbabba
bbaaabaa -> aaababbabbaababbabba

# < a,b | bbaaababbbbaa=a >
bbaaababbbbaa -> a
bbaaababba -> aababbbbaa
bbaaabaa -> aababbbbaaaababbbbaa

# < a,b | bbaaabbaabbaa=a >
bbaaabbaabbaa -> a
bbaaabbaaa -> aabbaabbaa
bbaaaa -> aabbaabbaabbaabbaa

# < a,b | bbaaabbabbbba=a >
bbaaabbabbbba -> a
bbaaabbabba -> aaabbabbbba
bbaaabbaa -> aaabbabba
bbaaaa -> aaabbabbaabbabbbba

# < a,b | bbaaabbbaabba=a >
bbaaabbbaabba -> a
bbaaabbbaaa -> aaabbbaabba
bbaaaba -> aaabbbaabbabbbaabba

# < a,b | bbaaabbbbabba=a >
bbaaabbbbabba -> a
bbaaabbbbaa -> aaabbbbabba
bbaaabba -> aaabbbbabbaabbbbabba
bbaaaa -> aaabbbbabbaabbbbaa

# < a,b | bbaaabbbbbaaa=a >
bbaaabbbbbaaa -> a
bbaaabbba -> abbbbbaaa
bbaaaba -> abbbbbaaaaabbbbbaaa

# < a,b | bbaabaabbabba=a >
bbaabaabbabba -> a
bbaabaabbaa -> aabaabbabba
bbaabaaa -> aabaabbabbabaabbabba

# < a,b | bbaabaabbbbaa=a >
bbaabaabbbbaa -> a
bbaabaabba -> abaabbbbaa
bbaabaaa -> abaabbbbaaabaabbbbaa

# < a,b | bbaababbbabba=a >
bbaababbbabba -> a
bbaababbbaa -> aababbbabba
bbaababa -> aababbbabbababbbabba

# < a,b | bbaababbbbbaa=a >
bbaababbbbbaa -> a
bbaababbba -> ababbbbbaa
bbaababa -> ababbbbbaaababbbbbaa

# < a,b | bbaabbaabbbba=a >
bbaabbaabbbba -> a
bbaabbaabba -> aabbaabbbba
bbaaa -> aabbaabbbbaabbbba

# < a,b | bbaabbabbabba=a >
bbaabbabbabba -> a
bbaabbabbaa -> aabbabbabba
bbaabbaa -> aabbabbabbabbabbabba
bbaaa -> aabbabbabbabbabbabbabbabbabba

# < a,b | bbaabbbabbbba=a >
bbaabbbabbbba -> a
bbaabbbabba -> aabbbabbbba
bbaabbbaa -> aabbbabba
bbaaba -> aabbbabbabbbabbbba

# < a,b | bbaabbbbbabba=a >
bbaabbbbbabba -> a
bbaabbbbbaa -> aabbbbbabba
bbaabbba -> aabbbbbabbabbbbbabba
bbaaba -> aabbbbbabbabbbbbaa

# < a,b | bbaabbbbbbbaa=a >
bbaabbbbbbbaa -> a
bbaabbbbba -> abbbbbbbaa
bbaabbba -> abbbbbbbaaabbbbbbbaa
bbaaba -> abbbbbbbaaabbbbbbbaaabbbbbbbaa

# < a,b | bbabaabbabbba=a >
bbabaabbabbba -> a
bbabaabbaba -> abaabbabbba
bbabaaa -> abaabbabbbaabbabbba

# < a,b | bbabaabbbbaba=a >
bbabaabbbbaba -> a
bbabaabba -> aabbbbaba
bbabaaa -> aabbbbababaabbbbaba

# < a,b | bbababbbabbba=a >
bbababbbabbba -> a
bbababbbaba -> ababbbabbba
bbababa -> ababbbabbbabbbabbba

# < a,b | bbabbabbbbbba=a >
bbabbabbbbbba -> a
bbabbabbbba -> abbabbbbbba
bbabbabba -> abbabbbba
bbaa -> abbabbbbabbbbbba

# < a,b | bbabbbabbbbba=a >
bbabbbabbbbba -> a
bbabbbabbba -> abbbabbbbba
bbaba -> abbbabbbbbabbbbba

# < a,b | bbbaabbbabbba=a >
bbbaabbbabbba -> a
bbbaabbbaa -> aabbbabbba
bbbaaa -> aabbbabbbabbbabbba

# < a,b | baaaaaaaaababa=a >
baaaaaaaaababa -> a
baaaaaaaaabaa -> aaaaaaaaababa
baaaaaaaaaa -> aaaaaaaaababaaaaaaaababa

# < a,b | baaaaaaaabaaba=a >
baaaaaaaabaaba -> a
baaaaaaaabaaa -> aaaaaaaabaaba
baaaaaaaaa -> aaaaaaaabaabaaaaaabaaba

# < a,b | baaaaaaaababba=a >
baaaaaaaababba -> a
baaaaaaaababa -> aaaaaaaababba
baaaaaaaabaa -> aaaaaaaababa
baaaaaaaaa -> aaaaaaaababaaaaaaababba

# < a,b | baaaaaaaabbaba=a >
baaaaaaaabbaba -> a
baaaaaaaabbaa -> aaaaaaaabbaba
baaaaaaaaba -> aaaaaaaabbabaaaaaaabbaba
baaaaaaaaa -> aaaaaaaabbabaaaaaaabbaa

# < a,b | baaaaaaabaaaba=a >
baaaaaaabaaaba -> a
baaaaaaabaaaa -> aaaaaaabaaaba
baaaaaaaa -> aaaaaaabaaabaaaabaaaba

# < a,b | baaaaaaabaabaa=a >
baaaaaaabaabaa -> a
baaaaaaabaaa -> aaaaaabaabaa
baaaaaaaa -> aaaaaabaabaaaaaabaabaa

# < a,b | baaaaaaabaabba=a >
baaaaaaabaabba -> a
baaaaaaabaaba -> aaaaaaabaabba
baaaaaaabaaa -> aaaaaaabaaba
baaaaaaaa -> aaaaaaabaabaaaaabaabba

# < a,b | baaaaaaabababa=a >
baaaaaaabababa -> a
baaaaaaababaa -> aaaaaaabababa
baaaaaaabaa -> aaaaaaabababaaaaaabababa
baaaaaaaa -> aaaaaaabababaaaaaabababaaaaaabababa

# < a,b | baaaaaaababbba=a >
baaaaaaababbba -> a
baaaaaaababba -> aaaaaaababbba
baaaaaaababa -> aaaaaaababba
baaaaaaabaa -> aaaaaaababa
baaaaaaaa -> aaaaaaababaaaaaababbba

# < a,b | baaaaaaabbaaba=a >
baaaaaaabbaaba -> a
baaaaaaabbaaa -> aaaaaaabbaaba
baaaaaaaba -> aaaaaaabbaabaaaaabbaaba
baaaaaaaa -> aaaaaaabbaabaaaaabbaaa

# < a,b | baaaaaaabbabba=a >
baaaaaaabbabba -> a
baaaaaaabbaba -> aaaaaaabbabba
baaaaaaabbaa -> aaaaaaabbaba
baaaaaaaba -> aaaaaaabbabaaaaaabbabba
baaaaaaaa -> aaaaaaabbabaaaaaabbaba

# < a,b | baaaaaabaaaaba=a >
baaaaaabaaaaba -> a
baaaaaabaaaaa -> aaaaaabaaaaba
baaaaaaa -> aaaaaabaaaabaabaaaaba

# < a,b | baaaaaabaaabaa=a >
baaaaaabaaabaa -> a
baaaaaabaaaa -> aaaaabaaabaa
baaaaaaa -> aaaaabaaabaaaabaaabaa

# < a,b | baaaaaabaaabba=a >
baaaaaabaaabba -> a
baaaaaabaaaba -> aaaaaabaaabba
baaaaaabaaaa -> aaaaaabaaaba
baaaaaaa -> aaaaaabaaabaaabaaabba

# < a,b | baaaaaabaababa=a >
baaaaaabaababa -> a
baaaaaabaabaa -> aaaaaabaababa
baaaaaabaaa -> aaaaaabaababaaaaabaababa
baaaaaaa -> aaaaaabaababaaaaabaababaaaabaababa

# < a,b | baaaaaabaabbba=a >
baaaaaabaabbba -> a
baaaaaabaabba -> aaaaaabaabbba
baaaaaabaaba -> aaaaaabaabba
baaaaaabaaa -> aaaaaabaaba
baaaaaaa -> aaaaaabaabaaaabaabbba

# < a,b | baaaaaababaaba=a >
baaaaaababaaba -> a
baaaaaababaaa -> aaaaaababaaba
baaaaaabaa -> aaaaaababaabaaaababaaba
baaaaaaa -> aaaaaababaabaaaababaabaaaaababaaba

# < a,b | baaaaaabababba=a >
baaaaaabababba -> a
baaaaaabababa -> aaaaaabababba
baaaaaababaa -> aaaaaabababa
baaaaaabaa -> aaaaaabababaaaaabababba
baaaaaaa -> aaaaaabababaaaaabababbaaaaabababba

# < a,b | baaaaaababbaba=a >
baaaaaababbaba -> a
baaaaaababbaa -> aaaaaababbaba
baaaaaababa -> aaaaaababbabaaaaababbaba
baaaaaabaa -> aaaaaababbabaaaaababbaa
baaaaaaa -> aaaaaababbabaaaaababa

# < a,b | baaaaaababbbba=a >
baaaaaababbbba -> a
baaaaaababbba -> aaaaaababbbba
baaaaaababba -> aaaaaababbba
baaaaaababa -> aaaaaababba
baaaaaabaa -> aaaaaababa
baaaaaaa -> aaaaaababaaaaababbbba

# < a,b | baaaaaabbaaaba=a >
baaaaaabbaaaba -> a
baaaaaabbaaaa -> aaaaaabbaaaba
baaaaaaba -> aaaaaabbaaabaaabbaaaba
baaaaaaa -> aaaaaabbaaabaaabbaaaa

# < a,b | baaaaaabbaabba=a >
baaaaaabbaabba -> a
baaaaaabbaaba -> aaaaaabbaabba
baaaaaabbaaa -> aaaaaabbaaba
baaaaaaba -> aaaaaabbaabaaaabbaabba
baaaaaaa -> aaaaaabbaabaaaabbaaba

# < a,b | baaaaaabbababa=a >
baaaaaabbababa -> a
baaaaaabbabaa -> aaaaaabbababa
baaaaaabbaa -> aaaaaabbababaaaaabbababa
baaaaaaba -> aaaaaabbababaaaaabbababaaaaabbababa
baaaaaaa -> aaaaaabbababaaaaabbababaaaaabbabaa

# < a,b | baaaaaabbabbba=a >
baaaaaabbabbba -> a
baaaaaabbabba -> aaaaaabbabbba
baaaaaabbaba -> aaaaaabbabba
baaaaaabbaa -> aaaaaabbaba
baaaaaaba -> aaaaaabbabaaaaabbabbba
baaaaaaa -> aaaaaabbabaaaaabbabba

# < a,b | baaaaaabbbabba=a >
baaaaaabbbabba -> a
baaaaaabbbaba -> aaaaaabbbabba
baaaaaabbbaa -> aaaaaabbbaba
baaaaaabba -> aaaaaabbbabaaaaabbbabba
baaaaaaba -> aaaaaabbbabaaaaabbbaba
baaaaaaa -> aaaaaabbbabaaaaabbbaa

# < a,b | baaaaabaaaabaa=a >
baaaaabaaaabaa -> a
baaaaabaaaaa -> aaaabaaaabaa
baaaaaa -> aaaabaaaabaabaaaabaa

# < a,b | baaaaabaaaabba=a >
baaaaabaaaabba -> a
baaaaabaaaaba -> aaaaabaaaabba
baaaaabaaaaa -> aaaaabaaaaba
baaaaaa -> aaaaabaaaababaaaabba

# < a,b | baaaaabaaabaaa=a >
baaaaabaaabaaa -> a
baaaaabaaaa -> aaabaaabaaa
baaaaaa -> aaabaaabaaaabaaabaaa

# < a,b | baaaaabaaababa=a >
baaaaabaaababa -> a
baaaaabaaabaa -> aaaaabaaababa
baaaaabaaaa -> aaaaabaaababaaaabaaababa
baaaaaa -> aaaaabaaababaaaabaaababaabaaababa

# < a,b | baaaaabaaabbba=a >
baaaaabaaabbba -> a
baaaaabaaabba -> aaaaabaaabbba
baaaaabaaaba -> aaaaabaaabba
baaaaabaaaa -> aaaaabaaaba
baaaaaa -> aaaaabaaabaabaaabbba

# < a,b | baaaaabaabaaba=a >
baaaaabaabaaba -> a
baaaaabaabaaa -> aaaaabaabaaba
baaaaabaaa -> aaaaabaabaabaaabaabaaba
baaaaaa -> aaaaabaabaabaaabaabaabaaabaabaaba

# < a,b | baaaaabaababaa=a >
baaaaabaababaa -> a
baaaaabaabaa -> aaaabaababaa
baaaaabaaa -> aaaabaabaa
baaaaaa -> aaaabaabaaaabaababaa

# < a,b | baaaaabaababba=a >
baaaaabaababba -> a
baaaaabaababa -> aaaaabaababba
baaaaabaabaa -> aaaaabaababa
baaaaabaaa -> aaaaabaababaaaabaababba
baaaaaa -> aaaaabaababaaaabaababbaaabaababba

# < a,b | baaaaabaabbaba=a >
baaaaabaabbaba -> a
baaaaabaabbaa -> aaaaabaabbaba
baaaaabaaba -> aaaaabaabbabaaaabaabbaba
baaaaabaaa -> aaaaabaabbabaaaabaabbaa
baaaaaa -> aaaaabaabbabaaaabaabbaaaabaabbaba

# < a,b | baaaaabaabbbba=a >
baaaaabaabbbba -> a
baaaaabaabbba -> aaaaabaabbbba
baaaaabaabba -> aaaaabaabbba
baaaaabaaba -> aaaaabaabba
baaaaabaaa -> aaaaabaaba
baaaaaa -> aaaaabaabaaabaabbbba

# < a,b | baaaaababaaaba=a >
baaaaababaaaba -> a
baaaaababaaaa -> aaaaababaaaba
baaaaabaa -> aaaaababaaabaababaaaba
baaaaaa -> aaaaababaaabaababaaabaaaababaaaba

# < a,b | baaaaababaabaa=a >
baaaaababaabaa -> a
baaaaababaaa -> aaaababaabaa
baaaaabaa -> aaaababaabaaaababaabaa
baaaaaa -> aaaababaabaaaababaaa

# < a,b | baaaaababaabba=a >
baaaaababaabba -> a
baaaaababaaba -> aaaaababaabba
baaaaababaaa -> aaaaababaaba
baaaaabaa -> aaaaababaabaaababaabba
baaaaaa -> aaaaababaabaaababaabbaaaababaabba

# < a,b | baaaaababababa=a >
baaaaababababa -> a
baaaaabababaa -> aaaaababababa
baaaaababaa -> aaaaababababaaaababababa
baaaaabaa -> aaaaababababaaaababababaaaababababa
baaaaaa -> aaaaababababaaaababababaaaababababaaaababababa

# < a,b | baaaaabababbba=a >
baaaaabababbba -> a
baaaaabababba -> aaaaabababbba
baaaaabababa -> aaaaabababba
baaaaababaa -> aaaaabababa
baaaaabaa -> aaaaabababaaaabababbba
baaaaaa -> aaaaabababaaaabababbbaaaabababbba

# < a,b | baaaaababbabba=a >
baaaaababbabba -> a
baaaaababbaba -> aaaaababbabba
baaaaababbaa -> aaaaababbaba
baaaaababa -> aaaaababbabaaaababbabba
baaaaabaa -> aaaaababbabaaaababbaba
baaaaaa -> aaaaababbabaaaababbabaaaababbabba

# < a,b | baaaaababbbbba=a >
baaaaababbbbba -> a
baaaaababbbba -> aaaaababbbbba
baaaaababbba -> aaaaababbbba
baaaaababba -> aaaaababbba
baaaaababa -> aaaaababba
baaaaabaa -> aaaaababa
baaaaaa -> aaaaababaaaababbbbba

# < a,b | baaaaabbaaaaba=a >
baaaaabbaaaaba -> a
baaaaabbaaaaa -> aaaaabbaaaaba
baaaaaba -> aaaaabbaaaababbaaaaba
baaaaaa -> aaaaabbaaaababbaaaaa

# < a,b | baaaaabbaaabba=a >
baaaaabbaaabba -> a
baaaaabbaaaba -> aaaaabbaaabba
baaaaabbaaaa -> aaaaabbaaaba
baaaaaba -> aaaaabbaaabaabbaaabba
baaaaaa -> aaaaabbaaabaabbaaaba

# < a,b | baaaaabbaababa=a >
baaaaabbaababa -> a
baaaaabbaabaa -> aaaaabbaababa
baaaaabbaaa -> aaaaabbaababaaaabbaababa
baaaaaba -> aaaaabbaababaaaabbaababaaabbaababa
baaaaaa -> aaaaabbaababaaaabbaababaaabbaabaa

# < a,b | baaaaabbaabbba=a >
baaaaabbaabbba -> a
baaaaabbaabba -> aaaaabbaabbba
baaaaabbaaba -> aaaaabbaabba
baaaaabbaaa -> aaaaabbaaba
baaaaaba -> aaaaabbaabaaabbaabbba
baaaaaa -> aaaaabbaabaaabbaabba

# < a,b | baaaaabbabaaba=a >
baaaaabbabaaba -> a
baaaaabbabaaa -> aaaaabbabaaba
baaaaabbaa -> aaaaabbabaabaaabbabaaba
baaaaaba -> aaaaabbabaabaaabbabaabaaaabbabaaba
baaaaaa -> aaaaabbabaabaaabbabaabaaaabbabaaa

# < a,b | baaaaabbababba=a >
baaaaabbababba -> a
baaaaabbababa -> aaaaabbababba
baaaaabbabaa -> aaaaabbababa
baaaaabbaa -> aaaaabbababaaaabbababba
baaaaaba -> aaaaabbababaaaabbababbaaaabbababba
baaaaaa -> aaaaabbababaaaabbababbaaaabbababa

# < a,b | baaaaabbabbaba=a >
baaaaabbabbaba -> a
baaaaabbabbaa -> aaaaabbabbaba
baaaaabbaba -> aaaaabbabbabaaaabbabbaba
baaaaabbaa -> aaaaabbabbabaaaabbabbaa
baaaaaba -> aaaaabbabbabaaaabbaba
baaaaaa -> aaaaabbabbabaaaabbaa

# < a,b | baaaaabbabbbba=a >
baaaaabbabbbba -> a
baaaaabbabbba -> aaaaabbabbbba
baaaaabbabba -> aaaaabbabbba
baaaaabbaba -> aaaaabbabba
baaaaabbaa -> aaaaabbaba
baaaaaba -> aaaaabbabaaaabbabbbba
baaaaaa -> aaaaabbabaaaabbabbba

# < a,b | baaaaabbbaabba=a >
baaaaabbbaabba -> a
baaaaabbbaaba -> aaaaabbbaabba
baaaaabbbaaa -> aaaaabbbaaba
baaaaabba -> aaaaabbbaabaaabbbaabba
baaaaaba -> aaaaabbbaabaaabbbaaba
baaaaaa -> aaaaabbbaabaaabbbaaa

# < a,b | baaaaabbbabbba=a >
baaaaabbbabbba -> a
baaaaabbbabba -> aaaaabbbabbba
baaaaabbbaba -> aaaaabbbabba
baaaaabbbaa -> aaaaabbbaba
baaaaabba -> aaaaabbbabaaaabbbabbba
baaaaaba -> aaaaabbbabaaaabbbabba
baaaaaa -> aaaaabbbabaaaabbbaba

# < a,b | baaaabaaaababa=a >
baaaabaaaababa -> a
baaaabaaaabaa -> aaaabaaaababa
baaaaa -> aaaabaaaababaaababa

# < a,b | baaaabaaaabbba=a >
baaaabaaaabbba -> a
baaaabaaaabba -> aaaabaaaabbba
baaaabaaaaba -> aaaabaaaabba
baaaaa -> aaaabaaaabbaaaabbba

# < a,b | baaaabaaabaaba=a >
baaaabaaabaaba -> a
baaaabaaabaaa -> aaaabaaabaaba
baaaabaaaa -> aaaabaaabaabaabaaabaaba
baaaaa -> aaaabaaabaabaabaaabaababaaabaaba

# < a,b | baaaabaaababaa=a >
baaaabaaababaa -> a
baaaabaaabaa -> aaabaaababaa
baaaabaaaa -> aaabaaabaa
baaaaa -> aaabaaabaabaaababaa

# < a,b | baaaabaaababba=a >
baaaabaaababba -> a
baaaabaaababa -> aaaabaaababba
baaaabaaabaa -> aaaabaaababa
baaaabaaaa -> aaaabaaababaaabaaababba
baaaaa -> aaaabaaababaaabaaababbabaaababba

# < a,b | baaaabaaabbaba=a >
baaaabaaabbaba -> a
baaaabaaabbaa -> aaaabaaabbaba
baaaabaaaba -> aaaabaaabbabaaabaaabbaba
baaaabaaaa -> aaaabaaabbabaaabaaabbaa
baaaaa -> aaaabaaabbabaaabaaabbaabaaabbaba

# < a,b | baaaabaaabbbba=a >
baaaabaaabbbba -> a
baaaabaaabbba -> aaaabaaabbbba
baaaabaaabba -> aaaabaaabbba
baaaabaaaba -> aaaabaaabba
baaaabaaaa -> aaaabaaaba
baaaaa -> aaaabaaababaaabbbba

# < a,b | baaaabaabaaaba=a >
baaaabaabaaaba -> a
baaaabaabaaaa -> aaaabaabaaaba
baaaabaaa -> aaaabaabaaababaabaaaba
baaaaa -> aaaabaabaaababaabaaabaabaabaaaba

# < a,b | baaaabaabaabaa=a >
baaaabaabaabaa -> a
baaaabaabaaa -> aaabaabaabaa
baaaabaaa -> aaabaabaabaaabaabaabaa
baaaaa -> aaabaabaabaaabaabaabaaabaabaabaa

# < a,b | baaaabaabaabba=a >
baaaabaabaabba -> a
baaaabaabaaba -> aaaabaabaabba
baaaabaabaaa -> aaaabaabaaba
baaaabaaa -> aaaabaabaabaabaabaabba
baaaaa -> aaaabaabaabaabaabaabbaabaabaabba

# < a,b | baaaabaabababa=a >
baaaabaabababa -> a
baaaabaababaa -> aaaabaabababa
baaaabaabaa -> aaaabaabababaaabaabababa
baaaabaaa -> aaaabaabababaaabaabababaaabaabababa
baaaaa -> aaaabaabababaaabaabababaaabaabababaabaabababa

# < a,b | baaaabaababbba=a >
baaaabaababbba -> a
baaaabaababba -> aaaabaababbba
baaaabaababa -> aaaabaababba
baaaabaabaa -> aaaabaababa
baaaabaaa -> aaaabaababaaabaababbba
baaaaa -> aaaabaababaaabaababbbaabaababbba

# < a,b | baaaabaabbaaba=a >
baaaabaabbaaba -> a
baaaabaabbaaa -> aaaabaabbaaba
baaaabaaba -> aaaabaabbaabaabaabbaaba
baaaabaaa -> aaaabaabbaabaabaabbaaa
baaaaa -> aaaabaabbaabaabaaba

# < a,b | baaaabaabbabba=a >
baaaabaabbabba -> a
baaaabaabbaba -> aaaabaabbabba
baaaabaabbaa -> aaaabaabbaba
baaaabaaba -> aaaabaabbabaaabaabbabba
baaaabaaa -> aaaabaabbabaaabaabbaba
baaaaa -> aaaabaabbabaaabaabbabaabaabbabba

# < a,b | baaaabaabbbbba=a >
baaaabaabbbbba -> a
baaaabaabbbba -> aaaabaabbbbba
baaaabaabbba -> aaaabaabbbba
baaaabaabba -> aaaabaabbba
baaaabaaba -> aaaabaabba
baaaabaaa -> aaaabaaba
baaaaa -> aaaabaabaabaabbbbba

# < a,b | baaaababaaaaba=a >
baaaababaaaaba -> a
baaaabaa -> abaaaaba
baaaaa -> aaabaaaabababaaaaba

# < a,b | baaaababaaabaa=a >
baaaababaaabaa -> a
baaaababaaaa -> aaababaaabaa
baaaabaa -> aaababaaabaababaaabaa
baaaaa -> aaababaaabaababaaaa

# < a,b | baaaababaaabba=a >
baaaababaaabba -> a
baaaababaaaba -> aaaababaaabba
baaaababaaaa -> aaaababaaaba
baaaabaa -> aaaababaaabababaaabba
baaaaa -> aaaababaaabababaaabbaaababaaabba

# < a,b | baaaababaababa=a >
baaaababaababa -> a
baaaababaabaa -> aaaababaababa
baaaababaaa -> aaaababaababaaababaababa
baaaabaa -> aaaababaababaaababaababaababaababa
baaaaa -> aaaababaababaaababaababaababaababaaababaababa

# < a,b | baaaababaabbba=a >
baaaababaabbba -> a
baaaababaabba -> aaaababaabbba
baaaababaaba -> aaaababaabba
baaaababaaa -> aaaababaaba
baaaabaa -> aaaababaabaababaabbba
baaaaa -> aaaababaabaababaabbbaaababaabbba

# < a,b | baaaabababaaba=a >
baaaabababaaba -> a
baaaabababaaa -> aaaabababaaba
baaaababaa -> aaaabababaabaabababaaba
baaaabaa -> aaaabababaabaabababaabaaabababaaba
baaaaa -> aaaabababaabaabababaabaaabababaabaaabababaaba

# < a,b | baaaababababba=a >
baaaababababba -> a
baaaababababa -> aaaababababba
baaaabababaa -> aaaababababa
baaaababaa -> aaaababababaaababababba
baaaabaa -> aaaababababaaababababbaaababababba
baaaaa -> aaaababababaaababababbaaababababbaaababababba

# < a,b | baaaabababbaba=a >
baaaabababbaba -> a
baaaabababbaa -> aaaabababbaba
baaaabababa -> aaaabababbabaaabababbaba
baaaababaa -> aaaabababbabaaabababbaa
baaaabaa -> aaaabababbabaaabababa
baaaaa -> aaaabababbabaaabababaaabababbaba

# < a,b | baaaabababbbba=a >
baaaabababbbba -> a
baaaabababbba -> aaaabababbbba
baaaabababba -> aaaabababbba
baaaabababa -> aaaabababba
baaaababaa -> aaaabababa
baaaabaa -> aaaabababaaabababbbba
baaaaa -> aaaabababaaabababbbbaaabababbbba

# < a,b | baaaababbaabba=a >
baaaababbaabba -> a
baaaababbaaba -> aaaababbaabba
baaaababbaaa -> aaaababbaaba
baaaababa -> aaaababbaabaababbaabba
baaaabaa -> aaaababbaabaababbaaba
baaaaa -> aaaababbaabaababbaabaaababbaabba

# < a,b | baaaababbababa=a >
baaaababbababa -> a
baaaababbabaa -> aaaababbababa
baaaababbaa -> aaaababbababaaababbababa
baaaababa -> aaaababbababaaababbababaaababbababa
baaaabaa -> aaaababbababaaababbababaaababbabaa
baaaaa -> aaaababbababaaababbababaaababbaa

# < a,b | baaaababbabbba=a >
baaaababbabbba -> a
baaaababbabba -> aaaababbabbba
baaaababbaba -> aaaababbabba
baaaababbaa -> aaaababbaba
baaaababa -> aaaababbabaaababbabbba
baaaabaa -> aaaababbabaaababbabba
baaaaa -> aaaababbabaaababbabbaaababbabbba

# < a,b | baaaababbbabba=a >
baaaababbbabba -> a
baaaababbbaba -> aaaababbbabba
baaaababbbaa -> aaaababbbaba
baaaababba -> aaaababbbabaaababbbabba
baaaababa -> aaaababbbabaaababbbaba
baaaabaa -> aaaababbbabaaababbbaa
baaaaa -> aaaababbbabaaababba

# < a,b | baaaababbbbbba=a >
baaaababbbbbba -> a
baaaababbbbba -> aaaababbbbbba
baaaababbbba -> aaaababbbbba
baaaababbba -> aaaababbbba
baaaababba -> aaaababbba
baaaababa -> aaaababba
baaaabaa -> aaaababa
baaaaa -> aaaababaaababbbbbba

# < a,b | baaaabbaaababa=a >
baaaabbaaababa -> a
baaaabbaaabaa -> aaaabbaaababa
baaaabbaaaa -> aaaabbaaababaaabbaaababa
baaaaba -> aaaabbaaababaaabbaaabababbaaababa
baaaaa -> aaaabbaaababaaabbaaabababbaaabaa

# < a,b | baaaabbaaabbba=a >
baaaabbaaabbba -> a
baaaabbaaabba -> aaaabbaaabbba
baaaabbaaaba -> aaaabbaaabba
baaaabbaaaa -> aaaabbaaaba
baaaaba -> aaaabbaaababbaaabbba
baaaaa -> aaaabbaaababbaaabba

# < a,b | baaaabbaabaaba=a >
baaaabbaabaaba -> a
baaaabbaabaaa -> aaaabbaabaaba
baaaabbaaa -> aaaabbaabaabaabbaabaaba
baaaaba -> aaaabbaabaabaabbaabaabaabbaabaaba
baaaaa -> aaaabbaabaabaabbaabaabaabbaabaaa

# < a,b | baaaabbaababba=a >
baaaabbaababba -> a
baaaabbaababa -> aaaabbaababba
baaaabbaabaa -> aaaabbaababa
baaaabbaaa -> aaaabbaababaaabbaababba
baaaaba -> aaaabbaababaaabbaababbaabbaababba
baaaaa -> aaaabbaababaaabbaababbaabbaababa

# < a,b | baaaabbaabbaba=a >
baaaabbaabbaba -> a
baaaabbaabbaa -> aaaabbaabbaba
baaaabbaaba -> aaaabbaabbabaaabbaabbaba
baaaabbaaa -> aaaabbaabbabaaabbaabbaa
baaaaba -> aaaabbaabbabaaabbaabbaaabbaabbaba
baaaaa -> aaaabbaabbabaaabbaabbaaabbaabbaa

# < a,b | baaaabbaabbbba=a >
baaaabbaabbbba -> a
baaaabbaabbba -> aaaabbaabbbba
baaaabbaabba -> aaaabbaabbba
baaaabbaaba -> aaaabbaabba
baaaabbaaa -> aaaabbaaba
baaaaba -> aaaabbaabaabbaabbbba
baaaaa -> aaaabbaabaabbaabbba

# < a,b | baaaabbabaaaba=a >
baaaabbabaaaba -> a
baaaabbabaaaa -> aaaabbabaaaba
baaaabbaa -> aaaabbabaaababbabaaaba
baaaaba -> aaaabbabaaababbabaaabaaabbabaaaba
baaaaa -> aaaabbabaaababbabaaabaaabbabaaaa

# < a,b | baaaabbabaabba=a >
baaaabbabaabba -> a
baaaabbabaaba -> aaaabbabaabba
baaaabbabaaa -> aaaabbabaaba
baaaabbaa -> aaaabbabaabaabbabaabba
baaaaba -> aaaabbabaabaabbabaabbaaabbabaabba
baaaaa -> aaaabbabaabaabbabaabbaaabbabaaba

# < a,b | baaaabbabababa=a >
baaaabbabababa -> a
baaaabbababaa -> aaaabbabababa
baaaabbabaa -> aaaabbabababaaabbabababa
baaaabbaa -> aaaabbabababaaabbabababaaabbabababa
baaaaba -> aaaabbabababaaabbabababaaabbabababaaabbabababa
baaaaa -> aaaabbabababaaabbabababaaabbabababaaabbababaa

# < a,b | baaaabbababbba=a >
baaaabbababbba -> a
baaaabbababba -> aaaabbababbba
baaaabbababa -> aaaabbababba
baaaabbabaa -> aaaabbababa
baaaabbaa -> aaaabbababaaabbababbba
baaaaba -> aaaabbababaaabbababbbaaabbababbba
baaaaa -> aaaabbababaaabbababbbaaabbababba

# < a,b | baaaabbabbabba=a >
baaaabbabbabba -> a
baaaabbabbaba -> aaaabbabbabba
baaaabbabbaa -> aaaabbabbaba
baaaabbaba -> aaaabbabbabaaabbabbabba
baaaabbaa -> aaaabbabbabaaabbabbaba
baaaaba -> aaaabbabbabaaabbabbabaaabbabbabba
baaaaa -> aaaabbabbabaaabbabbabaaabbabbaba

# < a,b | baaaabbabbbbba=a >
baaaabbabbbbba -> a
baaaabbabbbba -> aaaabbabbbbba
baaaabbabbba -> aaaabbabbbba
baaaabbabba -> aaaabbabbba
baaaabbaba -> aaaabbabba
baaaabbaa -> aaaabbaba
baaaaba -> aaaabbabaaabbabbbbba
baaaaa -> aaaabbabaaabbabbbba

# < a,b | baaaabbbaaabba=a >
baaaabbbaaabba -> a
baaaabbbaaaba -> aaaabbbaaabba
baaaabbbaaaa -> aaaabbbaaaba
baaaabba -> aaaabbbaaababbbaaabba
baaaaba -> aaaabbbaaababbbaaaba
baaaaa -> aaaabbbaaababbbaaaa

# < a,b | baaaabbbaabbba=a >
baaaabbbaabbba -> a
baaaabbbaabba -> aaaabbbaabbba
baaaabbbaaba -> aaaabbbaabba
baaaabbbaaa -> aaaabbbaaba
baaaabba -> aaaabbbaabaabbbaabbba
baaaaba -> aaaabbbaabaabbbaabba
baaaaa -> aaaabbbaabaabbbaaba

# < a,b | baaaabbbababba=a >
baaaabbbababba -> a
baaaabbbababa -> aaaabbbababba
baaaabbbabaa -> aaaabbbababa
baaaabbbaa -> aaaabbbababaaabbbababba
baaaabba -> aaaabbbababaaabbbababbaaabbbababba
baaaaba -> aaaabbbababaaabbbababbaaabbbababa
baaaaa -> aaaabbbababaaabbbababbaaabbbabaa

# < a,b | baaaabbbabbbba=a >
baaaabbbabbbba -> a
baaaabbbabbba -> aaaabbbabbbba
baaaabbbabba -> aaaabbbabbba
baaaabbbaba -> aaaabbbabba
baaaabbbaa -> aaaabbbaba
baaaabba -> aaaabbbabaaabbbabbbba
baaaaba -> aaaabbbabaaabbbabbba
baaaaa -> aaaabbbabaaabbbabba

# < a,b | baaaabbbbabbba=a >
baaaabbbbabbba -> a
baaaabbbbabba -> aaaabbbbabbba
baaaabbbbaba -> aaaabbbbabba
baaaabbbbaa -> aaaabbbbaba
baaaabbba -> aaaabbbbabaaabbbbabbba
baaaabba -> aaaabbbbabaaabbbbabba
baaaaba -> aaaabbbbabaaabbbbaba
baaaaa -> aaaabbbbabaaabbbbaa

# < a,b | baaabaaaaababa=a >
baaabaaaaababa -> a
baaabaaaaabaa -> aaabaaaaababa
baaabaaaaaa -> aaabaaaaababaabaaaaababa

# < a,b | baaabaaaaabbaa=a >
baaabaaaaabbaa -> a
baaabaaaaaba -> aabaaaaabbaa
baaabaaaaaa -> aabaaaaabbaaaabaaaaabbaa

# < a,b | baaabaaaabaaba=a >
baaabaaaabaaba -> a
baaabaaaabaaa -> aaabaaaabaaba
baaabaaaaa -> aaabaaaabaababaaaabaaba

# < a,b | baaabaaaababba=a >
baaabaaaababba -> a
baaabaaaababa -> aaabaaaababba
baaabaaaabaa -> aaabaaaababa
baaabaaaaa -> aaabaaaababaabaaaababba

# < a,b | baaabaaaabbaaa=a >
baaabaaaabbaaa -> a
baaabaaaaba -> abaaaabbaaa
baaabaaaaa -> abaaaabbaaaaabaaaabbaaa

# < a,b | baaabaaaabbaba=a >
baaabaaaabbaba -> a
baaabaaaabbaa -> aaabaaaabbaba
baaabaaaaba -> aaabaaaabbabaabaaaabbaba
baaabaaaaa -> aaabaaaabbabaabaaaabbaa

# < a,b | baaabaaaabbbaa=a >
baaabaaaabbbaa -> a
baaabaaaabba -> aabaaaabbbaa
baaabaaaaba -> aabaaaabbbaaaabaaaabbbaa
baaabaaaaa -> aabaaaabbbaaaabaaaabbbaaaabaaaabbbaa

# < a,b | baaabaaabaabaa=a >
baaabaaabaabaa -> a
baaabaaabaaa -> aabaaabaabaa
baaaa -> aabaaabaabaabaabaa

# < a,b | baaabaaabaabba=a >
baaabaaabaabba -> a
baaabaaabaaba -> aaabaaabaabba
baaabaaabaaa -> aaabaaabaaba
baaaa -> aaabaaabaababaabba

# < a,b | baaabaaabababa=a >
baaabaaabababa -> a
baaabaaababaa -> aaabaaabababa
baaabaaabaa -> aaabaaabababaabaaabababa
baaaa -> aaabaaabababaabaaabababaabababa

# < a,b | baaabaaababbba=a >
baaabaaababbba -> a
baaabaaababba -> aaabaaababbba
baaabaaababa -> aaabaaababba
baaabaaabaa -> aaabaaababa
baaaa -> aaabaaababaababbba

# < a,b | baaabaaabbaaba=a >
baaabaaabbaaba -> a
baaabaaabbaaa -> aaabaaabbaaba
baaabaaaba -> aaabaaabbaababaaabbaaba
baaaa -> aaabaaabbaababaaabbaabaaabbaaba

# < a,b | baaabaaabbabba=a >
baaabaaabbabba -> a
baaabaaabbaba -> aaabaaabbabba
baaabaaabbaa -> aaabaaabbaba
baaabaaaba -> aaabaaabbabaabaaabbabba
baaaa -> aaabaaabbabaabaaabbabbaaabbabba

# < a,b | baaabaaabbbbba=a >
baaabaaabbbbba -> a
baaabaaabbbba -> aaabaaabbbbba
baaabaaabbba -> aaabaaabbbba
baaabaaabba -> aaabaaabbba
baaabaaaba -> aaabaaabba
baaaa -> aaabaaabbaaabbbbba

# < a,b | baaabaabaaabaa=a >
baaabaabaaabaa -> a
baaabaaa -> abaaabaa
baaaa -> abaaabaabaabaaabaa

# < a,b | baaabaabaaabba=a >
baaabaabaaabba -> a
baaabaabaaaba -> aaabaabaaabba
baaabaaa -> aaabaabaaabbaabaaabba
baaaa -> aaabaabaaabbaabaaabbabaabaaabba

# < a,b | baaabaabaababa=a >
baaabaabaababa -> a
baaabaabaabaa -> aaabaabaababa
baaabaabaaa -> aaabaabaababaabaabaababa
baaabaaa -> aaabaabaababaabaabaabababaabaababa
baaaa -> aaabaabaababaabaabaabababaabaabababaabaababa

# < a,b | baaabaabaabbba=a >
baaabaabaabbba -> a
baaabaabaabba -> aaabaabaabbba
baaabaabaaba -> aaabaabaabba
baaabaabaaa -> aaabaabaaba
baaabaaa -> aaabaabaababaabaabbba
baaaa -> aaabaabaababaabaabbbabaabaabbba

# < a,b | baaabaababaaba=a >
baaabaababaaba -> a
baaabaababaaa -> aaabaababaaba
baaabaabaa -> aaabaababaababaababaaba
baaabaaa -> aaabaababaababaababaabaabaababaaba
baaaa -> aaabaababaababaababaabaabaababaababaababaaba

# < a,b | baaabaabababaa=a >
baaabaabababaa -> a
baaabaababaa -> aabaabababaa
baaabaabaa -> aabaababaa
baaabaaa -> aabaabaa
baaaa -> aabaabaabaabababaa

# < a,b | baaabaabababba=a >
baaabaabababba -> a
baaabaabababa -> aaabaabababba
baaabaababaa -> aaabaabababa
baaabaabaa -> aaabaabababaabaabababba
baaabaaa -> aaabaabababaabaabababbaabaabababba
baaaa -> aaabaabababaabaabababbaabaabababbabaabababba

# < a,b | baaabaababbaba=a >
baaabaababbaba -> a
baaabaababbaa -> aaabaababbaba
baaabaababa -> aaabaababbabaabaababbaba
baaabaabaa -> aaabaababbabaabaababbaa
baaabaaa -> aaabaababbabaabaababa
baaaa -> aaabaababbabaabaabababaababbaba

# < a,b | baaabaababbbba=a >
baaabaababbbba -> a
baaabaababbba -> aaabaababbbba
baaabaababba -> aaabaababbba
baaabaababa -> aaabaababba
baaabaabaa -> aaabaababa
baaabaaa -> aaabaababaabaababbbba
baaaa -> aaabaababaabaababbbbabaababbbba

# < a,b | baaabaabbaabba=a >
baaabaabbaabba -> a
baaabaabbaaba -> aaabaabbaabba
baaabaabbaaa -> aaabaabbaaba
baaabaaba -> aaabaabbaababaabbaabba
baaabaaa -> aaabaabbaababaabbaaba
baaaa -> aaabaabbaababaabbaababaabbaabba

# < a,b | baaabaabbababa=a >
baaabaabbababa -> a
baaabaabbabaa -> aaabaabbababa
baaabaabbaa -> aaabaabbababaabaabbababa
baaabaaba -> aaabaabbababaabaabbababaabaabbababa
baaabaaa -> aaabaabbababaabaabbababaabaabbabaa
baaaa -> aaabaabbababaabaabbababaabaabbabaabaabbababa

# < a,b | baaabaabbabbba=a >
baaabaabbabbba -> a
baaabaabbabba -> aaabaabbabbba
baaabaabbaba -> aaabaabbabba
baaabaabbaa -> aaabaabbaba
baaabaaba -> aaabaabbabaabaabbabbba
baaabaaa -> aaabaabbabaabaabbabba
baaaa -> aaabaabbabaabaabbabbabaabbabbba

# < a,b | baaabaabbbabba=a >
baaabaabbbabba -> a
baaabaabbbaba -> aaabaabbbabba
baaabaabbbaa -> aaabaabbbaba
baaabaabba -> aaabaabbbabaabaabbbabba
baaabaaba -> aaabaabbbabaabaabbbaba
baaabaaa -> aaabaabbbabaabaabbbaa
baaaa -> aaabaabbbabaabaabbbaabaabbbabba

# < a,b | baaabaabbbbbba=a >
baaabaabbbbbba -> a
baaabaabbbbba -> aaabaabbbbbba
baaabaabbbba -> aaabaabbbbba
baaabaabbba -> aaabaabbbba
baaabaabba -> aaabaabbba
baaabaaba -> aaabaabba
baaabaaa -> aaabaaba
baaaa -> aaabaababaabbbbbba

# < a,b | baaababaaababa=a >
baaababaaababa -> a
baaabaa -> aaababa
baaaa -> aaababaababaaababa

# < a,b | baaababaaabbaa=a >
baaababaaabbaa -> a
baaababaaaba -> aababaaabbaa
baaabaa -> aababaaabbaabaaabbaa
baaaa -> aababaaabbaabaaaba

# < a,b | baaababaaabbba=a >
baaababaaabbba -> a
baaababaaabba -> aaababaaabbba
baaababaaaba -> aaababaaabba
baaabaa -> aaababaaabbabaaabbba
baaaa -> aaababaaabbabaaabbbaababaaabbba

# < a,b | baaababaabaaba=a >
baaababaabaaba -> a
baaababaabaaa -> aaababaabaaba
baaababaaa -> aaababaabaabababaabaaba
baaabaa -> aaababaabaabababaabaabababaabaaba
baaaa -> aaababaabaabababaabaabababaabaabaababaabaaba

# < a,b | baaababaababaa=a >
baaababaababaa -> a
baaababaabaa -> aababaababaa
baaababaaa -> aababaabaa
baaabaa -> aababaabaababaababaa
baaaa -> aababaabaababaabaa

# < a,b | baaababaababba=a >
baaababaababba -> a
baaababaababa -> aaababaababba
baaababaabaa -> aaababaababa
baaababaaa -> aaababaababaababaababba
baaabaa -> aaababaababaababaababbababaababba
baaaa -> aaababaababaababaababbababaababbaababaababba

# < a,b | baaababaabbaba=a >
baaababaabbaba -> a
baaababaabbaa -> aaababaabbaba
baaababaaba -> aaababaabbabaababaabbaba
baaababaaa -> aaababaabbabaababaabbaa
baaabaa -> aaababaabbabaababaabbaababaabbaba
baaaa -> aaababaabbabaababaabbaababaabbabaababaabbaba

# < a,b | baaababaabbbba=a >
baaababaabbbba -> a
baaababaabbba -> aaababaabbbba
baaababaabba -> aaababaabbba
baaababaaba -> aaababaabba
baaababaaa -> aaababaaba
baaabaa -> aaababaabababaabbbba
baaaa -> aaababaabababaabbbbaababaabbbba

# < a,b | baaabababaabba=a >
baaabababaabba -> a
baaabababaaba -> aaabababaabba
baaabababaaa -> aaabababaaba
baaababaa -> aaabababaababababaabba
baaabaa -> aaabababaababababaabbaabababaabba
baaaa -> aaabababaababababaabbaabababaabbaabababaabba

# < a,b | baaabababababa=a >
baaabababababa -> a
baaababababaa -> aaabababababa
baaabababaa -> aaabababababaabababababa
baaababaa -> aaabababababaabababababaabababababa
baaabaa -> aaabababababaabababababaabababababaabababababa
baaaa -> aaabababababaabababababaabababababaabababababaabababababa

# < a,b | baaababababbba=a >
baaababababbba -> a
baaababababba -> aaababababbba
baaababababa -> aaababababba
baaabababaa -> aaababababa
baaababaa -> aaababababaababababbba
baaabaa -> aaababababaababababbbaababababbba
baaaa -> aaababababaababababbbaababababbbaababababbba

# < a,b | baaabababbabba=a >
baaabababbabba -> a
baaabababbaba -> aaabababbabba
baaabababbaa -> aaabababbaba
baaabababa -> aaabababbabaabababbabba
baaababaa -> aaabababbabaabababbaba
baaabaa -> aaabababbabaabababbabaabababbabba
baaaa -> aaabababbabaabababbabaabababbabbaabababbabba

# < a,b | baaabababbbbba=a >
baaabababbbbba -> a
baaabababbbba -> aaabababbbbba
baaabababbba -> aaabababbbba
baaabababba -> aaabababbba
baaabababa -> aaabababba
baaababaa -> aaabababa
baaabaa -> aaabababaabababbbbba
baaaa -> aaabababaabababbbbbaabababbbbba

# < a,b | baaababbaaabba=a >
baaababbaaabba -> a
baaababbaaaba -> aaababbaaabba
baaababa -> aaababbaaabbabbaaabba
baaabaa -> aaababbaaabbabbaaaba
baaaa -> aaababbaaabbaaabbaaabbabbaaabba

# < a,b | baaababbaababa=a >
baaababbaababa -> a
baaababbaabaa -> aaababbaababa
baaababbaaa -> aaababbaababaababbaababa
baaababa -> aaababbaababaababbaababababbaababa
baaabaa -> aaababbaababaababbaababababbaabaa
baaaa -> aaababbaababaababbaababababbaaa

# < a,b | baaababbaabbba=a >
baaababbaabbba -> a
baaababbaabba -> aaababbaabbba
baaababbaaba -> aaababbaabba
baaababbaaa -> aaababbaaba
baaababa -> aaababbaabababbaabbba
baaabaa -> aaababbaabababbaabba
baaaa -> aaababbaabababbaabbaababbaabbba

# < a,b | baaababbababba=a >
baaababbababba -> a
baaababbababa -> aaababbababba
baaababbabaa -> aaababbababa
baaababbaa -> aaababbababaababbababba
baaababa -> aaababbababaababbababbaababbababba
baaabaa -> aaababbababaababbababbaababbababa
baaaa -> aaababbababaababbababbaababbababaababbababba

# < a,b | baaababbabbaba=a >
baaababbabbaba -> a
baaababbabbaa -> aaababbabbaba
baaababbaba -> aaababbabbabaababbabbaba
baaababbaa -> aaababbabbabaababbabbaa
baaababa -> aaababbabbabaababbaba
baaabaa -> aaababbabbabaababbaa
baaaa -> aaababbabbabaababa

# < a,b | baaababbabbbba=a >
baaababbabbbba -> a
baaababbabbba -> aaababbabbbba
baaababbabba -> aaababbabbba
baaababbaba -> aaababbabba
baaababbaa -> aaababbaba
baaababa -> aaababbabaababbabbbba
baaabaa -> aaababbabaababbabbba
baaaa -> aaababbabaababbabbbaababbabbbba

# < a,b | baaababbbabbba=a >
baaababbbabbba -> a
baaababbbabba -> aaababbbabbba
baaababbbaba -> aaababbbabba
baaababbbaa -> aaababbbaba
baaababba -> aaababbbabaababbbabbba
baaababa -> aaababbbabaababbbabba
baaabaa -> aaababbbabaababbbaba
baaaa -> aaababbbabaababbbabaababbbabbba

# < a,b | baaababbbbbbba=a >
baaababbbbbbba -> a
baaababbbbbba -> aaababbbbbbba
baaababbbbba -> aaababbbbbba
baaababbbba -> aaababbbbba
baaababbba -> aaababbbba
baaababba -> aaababbba
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababbbbbbba

# < a,b | baaabbaaaababa=a >
baaabbaaaababa -> a
baaabbaaaabaa -> aaabbaaaababa
baaabbaaaaa -> aaabbaaaababaabbaaaababa

# < a,b | baaabbaaaabbaa=a >
baaabbaaaabbaa -> a
baaabbaaaaba -> aabbaaaabbaa
baaabbaaaaa -> aabbaaaabbaaaabbaaaabbaa

# < a,b | baaabbaaabaaba=a >
baaabbaaabaaba -> a
baaabbaaabaaa -> aaabbaaabaaba
baaabbaaaa -> aaabbaaabaababbaaabaaba

# < a,b | baaabbaaababba=a >
baaabbaaababba -> a
baaabbaaababa -> aaabbaaababba
baaabbaaabaa -> aaabbaaababa
baaabbaaaa -> aaabbaaababaabbaaababba

# < a,b | baaabbaaabbaba=a >
baaabbaaabbaba -> a
baaabbaaabbaa -> aaabbaaabbaba
baaaba -> aaabbaaabbabaabbaba
baaaa -> aaabbaaabbabaabbaa

# < a,b | baaabbaaabbbba=a >
baaabbaaabbbba -> a
baaabbaaabbba -> aaabbaaabbbba
baaabbaaabba -> aaabbaaabbba
baaaba -> aaabbaaabbbaaabbbba
baaaa -> aaabbaaabbbaaabbba

# < a,b | baaabbaabaabba=a >
baaabbaabaabba -> a
baaabbaabaaba -> aaabbaabaabba
baaabbaabaaa -> aaabbaabaaba
baaabbaaa -> aaabbaabaababbaabaabba
baaaba -> aaabbaabaababbaabaabbabbaabaabba
baaaa -> aaabbaabaababbaabaabbabbaabaaba

# < a,b | baaabbaabababa=a >
baaabbaabababa -> a
baaabbaababaa -> aaabbaabababa
baaabbaabaa -> aaabbaabababaabbaabababa
baaabbaaa -> aaabbaabababaabbaabababaabbaabababa
baaaba -> aaabbaabababaabbaabababaabbaababababbaabababa
baaaa -> aaabbaabababaabbaabababaabbaababababbaababaa

# < a,b | baaabbaababbba=a >
baaabbaababbba -> a
baaabbaababba -> aaabbaababbba
baaabbaababa -> aaabbaababba
baaabbaabaa -> aaabbaababa
baaabbaaa -> aaabbaababaabbaababbba
baaaba -> aaabbaababaabbaababbbabbaababbba
baaaa -> aaabbaababaabbaababbbabbaababba

# < a,b | baaabbaabbaaba=a >
baaabbaabbaaba -> a
baaabbaabbaaa -> aaabbaabbaaba
baaabbaaba -> aaabbaabbaababbaabbaaba
baaabbaaa -> aaabbaabbaababbaabbaaa
baaaba -> aaabbaabbaababbaaba
baaaa -> aaabbaabbaababbaaa

# < a,b | baaabbaabbabba=a >
baaabbaabbabba -> a
baaabbaabbaba -> aaabbaabbabba
baaabbaabbaa -> aaabbaabbaba
baaabbaaba -> aaabbaabbabaabbaabbabba
baaabbaaa -> aaabbaabbabaabbaabbaba
baaaba -> aaabbaabbabaabbaabbababbaabbabba
baaaa -> aaabbaabbabaabbaabbababbaabbaba

# < a,b | baaabbaabbbbba=a >
baaabbaabbbbba -> a
baaabbaabbbba -> aaabbaabbbbba
baaabbaabbba -> aaabbaabbbba
baaabbaabba -> aaabbaabbba
baaabbaaba -> aaabbaabba
baaabbaaa -> aaabbaaba
baaaba -> aaabbaababbaabbbbba
baaaa -> aaabbaababbaabbbba

# < a,b | baaabbabaababa=a >
baaabbabaababa -> a
baaabbabaabaa -> aaabbabaababa
baaabbabaaa -> aaabbabaababaabbabaababa
baaabbaa -> aaabbabaababaabbabaabababbabaababa
baaaba -> aaabbabaababaabbabaabababbabaababaabbabaababa
baaaa -> aaabbabaababaabbabaabababbabaababaabbabaabaa

# < a,b | baaabbabaabbba=a >
baaabbabaabbba -> a
baaabbabaabba -> aaabbabaabbba
baaabbabaaba -> aaabbabaabba
baaabbabaaa -> aaabbabaaba
baaabbaa -> aaabbabaababbabaabbba
baaaba -> aaabbabaababbabaabbbaabbabaabbba
baaaa -> aaabbabaababbabaabbbaabbabaabba

# < a,b | baaabbababaaba=a >
baaabbababaaba -> a
baaabbababaaa -> aaabbababaaba
baaabbabaa -> aaabbababaababbababaaba
baaabbaa -> aaabbababaababbababaabaabbababaaba
baaaba -> aaabbababaababbababaabaabbababaabaabbababaaba
baaaa -> aaabbababaababbababaabaabbababaabaabbababaaa

# < a,b | baaabbabababba=a >
baaabbabababba -> a
baaabbabababa -> aaabbabababba
baaabbababaa -> aaabbabababa
baaabbabaa -> aaabbabababaabbabababba
baaabbaa -> aaabbabababaabbabababbaabbabababba
baaaba -> aaabbabababaabbabababbaabbabababbaabbabababba
baaaa -> aaabbabababaabbabababbaabbabababbaabbabababa

# < a,b | baaabbababbaba=a >
baaabbababbaba -> a
baaabbababbaa -> aaabbababbaba
baaabbababa -> aaabbababbabaabbababbaba
baaabbabaa -> aaabbababbabaabbababbaa
baaabbaa -> aaabbababbabaabbababa
baaaba -> aaabbababbabaabbababaabbababbaba
baaaa -> aaabbababbabaabbababaabbababbaa

# < a,b | baaabbababbbba=a >
baaabbababbbba -> a
baaabbababbba -> aaabbababbbba
baaabbababba -> aaabbababbba
baaabbababa -> aaabbababba
baaabbabaa -> aaabbababa
baaabbaa -> aaabbababaabbababbbba
baaaba -> aaabbababaabbababbbbaabbababbbba
baaaa -> aaabbababaabbababbbbaabbababbba

# < a,b | baaabbabbaabba=a >
baaabbabbaabba -> a
baaabbabbaaba -> aaabbabbaabba
baaabbabbaaa -> aaabbabbaaba
baaabbaba -> aaabbabbaababbabbaabba
baaabbaa -> aaabbabbaababbabbaaba
baaaba -> aaabbabbaababbabbaabaabbabbaabba
baaaa -> aaabbabbaababbabbaabaabbabbaaba

# < a,b | baaabbabbabbba=a >
baaabbabbabbba -> a
baaabbabbabba -> aaabbabbabbba
baaabbabbaba -> aaabbabbabba
baaabbabbaa -> aaabbabbaba
baaabbaba -> aaabbabbabaabbabbabbba
baaabbaa -> aaabbabbabaabbabbabba
baaaba -> aaabbabbabaabbabbabbaabbabbabbba
baaaa -> aaabbabbabaabbabbabbaabbabbabba

# < a,b | baaabbabbbabba=a >
baaabbabbbabba -> a
baaabbabbbaba -> aaabbabbbabba
baaabbabbbaa -> aaabbabbbaba
baaabbabba -> aaabbabbbabaabbabbbabba
baaabbaba -> aaabbabbbabaabbabbbaba
baaabbaa -> aaabbabbbabaabbabbbaa
baaaba -> aaabbabbbabaabbabba
baaaa -> aaabbabbbabaabbaba

# < a,b | baaabbabbbbbba=a >
baaabbabbbbbba -> a
baaabbabbbbba -> aaabbabbbbbba
baaabbabbbba -> aaabbabbbbba
baaabbabbba -> aaabbabbbba
baaabbabba -> aaabbabbba
baaabbaba -> aaabbabba
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbabbbbbba
baaaa -> aaabbabaabbabbbbba

# < a,b | baaabbbaaababa=a >
baaabbbaaababa -> a
baaabbbaaabaa -> aaabbbaaababa
baaabbbaaaa -> aaabbbaaababaabbbaaababa

# < a,b | baaabbbaaabbaa=a >
baaabbbaaabbaa -> a
baaabbbaaaba -> aabbbaaabbaa
baaabbbaaaa -> aabbbaaabbaaaabbbaaabbaa

# < a,b | baaabbbaababba=a >
baaabbbaababba -> a
baaabbbaababa -> aaabbbaababba
baaabbbaabaa -> aaabbbaababa
baaabbbaaa -> aaabbbaababaabbbaababba
baaabba -> aaabbbaababaabbbaababbabbbaababba
baaaba -> aaabbbaababaabbbaababbabbbaababa
baaaa -> aaabbbaababaabbbaababbabbbaabaa

# < a,b | baaabbbaabbbba=a >
baaabbbaabbbba -> a
baaabbbaabbba -> aaabbbaabbbba
baaabbbaabba -> aaabbbaabbba
baaabbbaaba -> aaabbbaabba
baaabbbaaa -> aaabbbaaba
baaabba -> aaabbbaababbbaabbbba
baaaba -> aaabbbaababbbaabbba
baaaa -> aaabbbaababbbaabba

# < a,b | baaabbbabaabba=a >
baaabbbabaabba -> a
baaabbbabaaba -> aaabbbabaabba
baaabbbabaaa -> aaabbbabaaba
baaabbbaa -> aaabbbabaababbbabaabba
baaabba -> aaabbbabaababbbabaabbaabbbabaabba
baaaba -> aaabbbabaababbbabaabbaabbbabaaba
baaaa -> aaabbbabaababbbabaabbaabbbabaaa

# < a,b | baaabbbababbba=a >
baaabbbababbba -> a
baaabbbababba -> aaabbbababbba
baaabbbababa -> aaabbbababba
baaabbbabaa -> aaabbbababa
baaabbbaa -> aaabbbababaabbbababbba
baaabba -> aaabbbababaabbbababbbaabbbababbba
baaaba -> aaabbbababaabbbababbbaabbbababba
baaaa -> aaabbbababaabbbababbbaabbbababa

# < a,b | baaabbbabbabba=a >
baaabbbabbabba -> a
baaabbbabbaba -> aaabbbabbabba
baaabbbabbaa -> aaabbbabbaba
baaabbbaba -> aaabbbabbabaabbbabbabba
baaabbbaa -> aaabbbabbabaabbbabbaba
baaabba -> aaabbbabbabaabbbabbabaabbbabbabba
baaaba -> aaabbbabbabaabbbabbabaabbbabbaba
baaaa -> aaabbbabbabaabbbabbabaabbbabbaa

# < a,b | baaabbbabbbbba=a >
baaabbbabbbbba -> a
baaabbbabbbba -> aaabbbabbbbba
baaabbbabbba -> aaabbbabbbba
baaabbbabba -> aaabbbabbba
baaabbbaba -> aaabbbabba
baaabbbaa -> aaabbbaba
baaabba -> aaabbbabaabbbabbbbba
baaaba -> aaabbbabaabbbabbbba
baaaa -> aaabbbabaabbbabbba

# < a,b | baaabbbbaabbba=a >
baaabbbbaabbba -> a
baaabbbbaabba -> aaabbbbaabbba
baaabbbbaaba -> aaabbbbaabba
baaabbbbaaa -> aaabbbbaaba
baaabbba -> aaabbbbaababbbbaabbba
baaabba -> aaabbbbaababbbbaabba
baaaba -> aaabbbbaababbbbaaba
baaaa -> aaabbbbaababbbbaaa

# < a,b | baaabbbbabbbba=a >
baaabbbbabbbba -> a
baaabbbbabbba -> aaabbbbabbbba
baaabbbbabba -> aaabbbbabbba
baaabbbbaba -> aaabbbbabba
baaabbbbaa -> aaabbbbaba
baaabbba -> aaabbbbabaabbbbabbbba
baaabba -> aaabbbbabaabbbbabbba
baaaba -> aaabbbbabaabbbbabba
baaaa -> aaabbbbabaabbbbaba

# < a,b | baabaaaaaababa=a >
baabaaaaaababa -> a
baabaaaaaabaa -> aabaaaaaababa
baabaaaaaaa -> aabaaaaaabababaaaaaababa

# < a,b | baabaaaaaabbaa=a >
baabaaaaaabbaa -> a
baabaaaaaaba -> abaaaaaabbaa
baabaaaaaaa -> abaaaaaabbaaabaaaaaabbaa

# < a,b | baabaaaaababba=a >
baabaaaaababba -> a
baabaaaaababa -> aabaaaaababba
baabaaaaabaa -> aabaaaaababa
baabaaaaaa -> aabaaaaabababaaaaababba

# < a,b | baabaaaaabbaba=a >
baabaaaaabbaba -> a
baabaaaaabbaa -> aabaaaaabbaba
baabaaaaaba -> aabaaaaabbababaaaaabbaba
baabaaaaaa -> aabaaaaabbababaaaaabbaa

# < a,b | baabaaaaabbbaa=a >
baabaaaaabbbaa -> a
baabaaaaabba -> abaaaaabbbaa
baabaaaaaba -> abaaaaabbbaaabaaaaabbbaa
baabaaaaaa -> abaaaaabbbaaabaaaaabbbaaabaaaaabbbaa

# < a,b | baabaaaabaabba=a >
baabaaaabaabba -> a
baabaaaabaaba -> aabaaaabaabba
baabaaaabaaa -> aabaaaabaaba
baabaaaaa -> aabaaaabaabbaaaabaabba

# < a,b | baabaaaabababa=a >
baabaaaabababa -> a
baabaaaababaa -> aabaaaabababa
baabaaaabaa -> aabaaaababababaaaabababa
baabaaaaa -> aabaaaababababaaaababababaaaabababa

# < a,b | baabaaaababbaa=a >
baabaaaababbaa -> a
baabaaaababa -> abaaaababbaa
baabaaaabaa -> abaaaababbaaabaaaababbaa
baabaaaaa -> abaaaababbaaabaaaababa

# < a,b | baabaaaababbba=a >
baabaaaababbba -> a
baabaaaababba -> aabaaaababbba
baabaaaababa -> aabaaaababba
baabaaaabaa -> aabaaaababa
baabaaaaa -> aabaaaabababaaaababbba

# < a,b | baabaaaabbabaa=a >
baabaaaabbabaa -> a
baabaaaabbaa -> abaaaabbabaa
baabaaaaba -> abaaaabbaa
baabaaaaa -> abaaaabbaaabaaaabbabaa

# < a,b | baabaaaabbabba=a >
baabaaaabbabba -> a
baabaaaabbaba -> aabaaaabbabba
baabaaaabbaa -> aabaaaabbaba
baabaaaaba -> aabaaaabbababaaaabbabba
baabaaaaa -> aabaaaabbababaaaabbaba

# < a,b | baabaaaabbbaba=a >
baabaaaabbbaba -> a
baabaaaabbbaa -> aabaaaabbbaba
baabaaaabba -> aabaaaabbbababaaaabbbaba
baabaaaaba -> aabaaaabbbababaaaabbbaa
baabaaaaa -> aabaaaabbbababaaaabbbaaabaaaabbbaba

# < a,b | baabaaaabbbbaa=a >
baabaaaabbbbaa -> a
baabaaaabbba -> abaaaabbbbaa
baabaaaabba -> abaaaabbbbaaabaaaabbbbaa
baabaaaaba -> abaaaabbbbaaabaaaabbbbaaabaaaabbbbaa
baabaaaaa -> abaaaabbbbaaabaaaabbbbaaabaaaabbbbaaabaaaabbbbaa

# < a,b | baabaaabaababa=a >
baabaaabaababa -> a
baabaaabaabaa -> aabaaabaababa
baabaaabaaa -> aabaaabaabababaaabaababa
baabaaaa -> aabaaabaababaabaababa

# < a,b | baabaaabaabbaa=a >
baabaaabaabbaa -> a
baabaaabaaba -> abaaabaabbaa
baabaaabaaa -> abaaabaabbaaabaaabaabbaa
baabaaaa -> abaaabaabbaaaabaabbaa

# < a,b | baabaaabaabbba=a >
baabaaabaabbba -> a
baabaaabaabba -> aabaaabaabbba
baabaaabaaba -> aabaaabaabba
baabaaabaaa -> aabaaabaaba
baabaaaa -> aabaaabaabbaaabaabbba

# < a,b | baabaaababaaba=a >
baabaaababaaba -> a
baabaaababaaa -> aabaaababaaba
baabaaabaa -> aaababaaba
baabaaaa -> aaababaababaaababaaba

# < a,b | baabaaabababba=a >
baabaaabababba -> a
baabaaabababa -> aabaaabababba
baabaaababaa -> aabaaabababa
baabaaabaa -> aabaaababababaaabababba
baabaaaa -> aabaaababababaaabababbabaaabababba

# < a,b | baabaaababbaba=a >
baabaaababbaba -> a
baabaaababbaa -> aabaaababbaba
baabaaababa -> aabaaababbababaaababbaba
baabaaabaa -> aabaaababbababaaababbaa
baabaaaa -> aabaaababbababaaababa

# < a,b | baabaaababbbaa=a >
baabaaababbbaa -> a
baabaaababba -> abaaababbbaa
baabaaababa -> abaaababbbaaabaaababbbaa
baabaaabaa -> abaaababbbaaabaaababbbaaabaaababbbaa
baabaaaa -> abaaababbbaaabaaababbbaaabaaababba

# < a,b | baabaaababbbba=a >
baabaaababbbba -> a
baabaaababbba -> aabaaababbbba
baabaaababba -> aabaaababbba
baabaaababa -> aabaaababba
baabaaabaa -> aabaaababa
baabaaaa -> aabaaabababaaababbbba

# < a,b | baabaaabbaabba=a >
baabaaabbaabba -> a
baabaaabbaaba -> aabaaabbaabba
baabaaabbaaa -> aabaaabbaaba
baabaaaba -> aabaaabbaabbaaabbaabba
baabaaaa -> aabaaabbaabbaaabbaaba

# < a,b | baabaaabbababa=a >
baabaaabbababa -> a
baabaaabbabaa -> aabaaabbababa
baabaaabbaa -> aabaaabbabababaaabbababa
baabaaaba -> aabaaabbabababaaabbabababaaabbababa
baabaaaa -> aabaaabbabababaaabbabababaaabbabaa

# < a,b | baabaaabbabbaa=a >
baabaaabbabbaa -> a
baabaaabbaba -> abaaabbabbaa
baabaaabbaa -> abaaabbabbaaabaaabbabbaa
baabaaaba -> abaaabbabbaaabaaabbaba
baabaaaa -> abaaabbabbaaabaaabbaa

# < a,b | baabaaabbabbba=a >
baabaaabbabbba -> a
baabaaabbabba -> aabaaabbabbba
baabaaabbaba -> aabaaabbabba
baabaaabbaa -> aabaaabbaba
baabaaaba -> aabaaabbababaaabbabbba
baabaaaa -> aabaaabbababaaabbabba

# < a,b | baabaaabbbaaba=a >
baabaaabbbaaba -> a
baabaaabbbaaa -> aabaaabbbaaba
baabaaabba -> aaabbbaaba
baabaaaba -> aaabbbaaa
baabaaaa -> aaabbbaaaabaaabbbaaba

# < a,b | baabaaabbbabaa=a >
baabaaabbbabaa -> a
baabaaabbbaa -> abaaabbbabaa
baabaaabba -> abaaabbbaa
baabaaaba -> abaaabbbaaabaaabbbabaa
baabaaaa -> abaaabbbaaabaaabbbabaaabaaabbbabaa

# < a,b | baabaaabbbabba=a >
baabaaabbbabba -> a
baabaaabbbaba -> aabaaabbbabba
baabaaabbbaa -> aabaaabbbaba
baabaaabba -> aabaaabbbababaaabbbabba
baabaaaba -> aabaaabbbababaaabbbaba
baabaaaa -> aabaaabbbababaaabbbaa

# < a,b | baabaaabbbbaba=a >
baabaaabbbbaba -> a
baabaaabbbbaa -> aabaaabbbbaba
baabaaabbba -> aabaaabbbbababaaabbbbaba
baabaaabba -> aabaaabbbbababaaabbbbaa
baabaaaba -> aabaaabbbbababaaabbbbaaabaaabbbbaba
baabaaaa -> aabaaabbbbababaaabbbbaaabaaabbbbaa

# < a,b | baabaaabbbbbaa=a >
baabaaabbbbbaa -> a
baabaaabbbba -> abaaabbbbbaa
baabaaabbba -> abaaabbbbbaaabaaabbbbbaa
baabaaabba -> abaaabbbbbaaabaaabbbbbaaabaaabbbbbaa
baabaaaba -> abaaabbbbbaaabaaabbbbbaaabaaabbbbbaaabaaabbbbbaa
baabaaaa -> abaaabbbbbaaabaaabbbbbaaabaaabbbbbaaabaaabbbbbaaabaaabbbbbaa

# < a,b | baabaabaaababa=a >
baabaabaaababa -> a
baabaabaaabaa -> aabaabaaababa
baabaabaaaa -> aabaabaaabababaabaaababa

# < a,b | baabaabaaabbaa=a >
baabaabaaabbaa -> a
baabaabaaaba -> abaabaaabbaa
baabaabaaaa -> abaabaaabbaaabaabaaabbaa

# < a,b | baabaabaababaa=a >
baabaabaababaa -> a
baabaabaabaa -> abaabaababaa
baaa -> abaabaababaababaa

# < a,b | baabaabaababba=a >
baabaabaababba -> a
baabaabaababa -> aabaabaababba
baabaabaabaa -> aabaabaababa
baaa -> aabaabaababababba

# < a,b | baabaabaabbaba=a >
baabaabaabbaba -> a
baabaabaabbaa -> aabaabaabbaba
baabaabaaba -> aabaabaabbababaabaabbaba
baaa -> aabaabaabbababaabaabbabaabbaba

# < a,b | baabaabaabbbba=a >
baabaabaabbbba -> a
baabaabaabbba -> aabaabaabbbba
baabaabaabba -> aabaabaabbba
baabaabaaba -> aabaabaabba
baaa -> aabaabaabbaabbbba

# < a,b | baabaababaabba=a >
baabaababaabba -> a
baabaababaaba -> aabaababaabba
baabaabaa -> aabaababaabbaababaabba
baaa -> aabaababaabbaababaabbababaabba

# < a,b | baabaababababa=a >
baabaababababa -> a
baabaabababaa -> aabaababababa
baabaababaa -> aabaabababababaababababa
baabaabaa -> aabaabababababaabababababaababababa
baaa -> aabaabababababaabababababaababababababababa

# < a,b | baabaabababbba=a >
baabaabababbba -> a
baabaabababba -> aabaabababbba
baabaabababa -> aabaabababba
baabaababaa -> aabaabababa
baabaabaa -> aabaababababaabababbba
baaa -> aabaababababaabababbbabababbba

# < a,b | baabaababbabba=a >
baabaababbabba -> a
baabaababbaba -> aabaababbabba
baabaababbaa -> aabaababbaba
baabaababa -> aabaababbababaababbabba
baabaabaa -> aabaababbababaababbaba
baaa -> aabaababbababaababbabababbabba

# < a,b | baabaababbbbba=a >
baabaababbbbba -> a
baabaababbbba -> aabaababbbbba
baabaababbba -> aabaababbbba
baabaababba -> aabaababbba
baabaababa -> aabaababba
baabaabaa -> aabaababa
baaa -> aabaababababbbbba

# < a,b | baabaabbaababa=a >
baabaabbaababa -> a
baabaabbaabaa -> aabaabbaababa
baabaaba -> aabaabbaabababbaababa
baaa -> aabaabbaabababbaababaabbaababa

# < a,b | baabaabbaabbba=a >
baabaabbaabbba -> a
baabaabbaabba -> aabaabbaabbba
baabaabbaaba -> aabaabbaabba
baabaaba -> aabaabbaabbaabbaabbba
baaa -> aabaabbaabbaabbaabbbaabbaabbba

# < a,b | baabaabbababba=a >
baabaabbababba -> a
baabaabbababa -> aabaabbababba
baabaabbabaa -> aabaabbababa
baabaabbaa -> aabaabbabababaabbababba
baabaaba -> aabaabbabababaabbababbabaabbababba
baaa -> aabaabbabababaabbababbabaabbababbaabbababba

# < a,b | baabaabbabbaba=a >
baabaabbabbaba -> a
baabaabbabbaa -> aabaabbabbaba
baabaabbaba -> aabaabbabbababaabbabbaba
baabaabbaa -> aabaabbabbababaabbabbaa
baabaaba -> aabaabbabbababaabbaba
baaa -> aabaabbabbababaabbabaabbabbaba

# < a,b | baabaabbabbbba=a >
baabaabbabbbba -> a
baabaabbabbba -> aabaabbabbbba
baabaabbabba -> aabaabbabbba
baabaabbaba -> aabaabbabba
baabaabbaa -> aabaabbaba
baabaaba -> aabaabbababaabbabbbba
baaa -> aabaabbababaabbabbbbaabbabbbba

# < a,b | baabaabbbaabba=a >
baabaabbbaabba -> a
baabaabbbaaba -> aabaabbbaabba
baabaabba -> aabaabbbaabbaabbbaabba
baabaaba -> aabaabbbaabbaabbbaaba
baaa -> aabaabbbaabbaabba

# < a,b | baabaabbbabbba=a >
baabaabbbabbba -> a
baabaabbbabba -> aabaabbbabbba
baabaabbbaba -> aabaabbbabba
baabaabbbaa -> aabaabbbaba
baabaabba -> aabaabbbababaabbbabbba
baabaaba -> aabaabbbababaabbbabba
baaa -> aabaabbbababaabbbabbaabbbabbba

# < a,b | baabaabbbbbbba=a >
baabaabbbbbbba -> a
baabaabbbbbba -> aabaabbbbbbba
baabaabbbbba -> aabaabbbbbba
baabaabbbba -> aabaabbbbba
baabaabbba -> aabaabbbba
baabaabba -> aabaabbba
baabaaba -> aabaabba
baaa -> aabaabbaabbbbbbba

# < a,b | baababaaaababa=a >
baababaaaababa -> a
baababaaaabaa -> aababaaaababa
baababaaaaa -> aababaaaababababaaaababa

# < a,b | baababaaaabbaa=a >
baababaaaabbaa -> a
baababaaaaba -> ababaaaabbaa
baababaaaaa -> ababaaaabbaaababaaaabbaa

# < a,b | baababaaababba=a >
baababaaababba -> a
baababaaababa -> aababaaababba
baababaaabaa -> aababaaababa
baababaaaa -> aababaaababababaaababba

# < a,b | baababaaabbaba=a >
baababaaabbaba -> a
baababaaabbaa -> aababaaabbaba
baababaaaba -> aababaaabbabababaaabbaba
baababaaaa -> aababaaabbabababaaabbaa

# < a,b | baababaaabbbaa=a >
baababaaabbbaa -> a
baababaaabba -> ababaaabbbaa
baababaaaba -> ababaaabbbaaababaaabbbaa
baababaaaa -> ababaaabbbaaababaaabbbaaababaaabbbaa

# < a,b | baababaabaabba=a >
baababaabaabba -> a
baababaabaaba -> aababaabaabba
baababaabaaa -> aababaabaaba
baababaaa -> aababaabaabbabaabaabba

# < a,b | baababaabababa=a >
baababaabababa -> a
baababaababaa -> aababaabababa
baabaa -> aababaababababababa
baaa -> aababaababababababababaabababa

# < a,b | baababaababbba=a >
baababaababbba -> a
baababaababba -> aababaababbba
baababaababa -> aababaababba
baabaa -> aababaababbaababbba
baaa -> aababaababbaababbbababaababbba

# < a,b | baababaabbaaba=a >
baababaabbaaba -> a
baababaaba -> abaabbaaba
baabaa -> abaaba
baaa -> abaabababaabbaaba

# < a,b | baababaabbabba=a >
baababaabbabba -> a
baababaabbaba -> aababaabbabba
baababaabbaa -> aababaabbaba
baababaaba -> aababaabbabababaabbabba
baabaa -> aababaabbabababaabbabbabaabbabba
baaa -> aababaabbabababaabbabbabaabbabbababaabbabba

# < a,b | baababaabbbbba=a >
baababaabbbbba -> a
baababaabbbba -> aababaabbbbba
baababaabbba -> aababaabbbba
baababaabba -> aababaabbba
baababaaba -> aababaabba
baabaa -> aababaabbabaabbbbba
baaa -> aababaabbabaabbbbbababaabbbbba

# < a,b | baabababaababa=a >
baabababaababa -> a
baababaa -> abaababa
baabaa -> abaabababababaababa
baaa -> abaabababababaabababababaababa

# < a,b | baabababaabbba=a >
baabababaabbba -> a
baabababaabba -> aabababaabbba
baabababaaba -> aabababaabba
baababaa -> aabababaabbababaabbba
baabaa -> aabababaabbababaabbbabababaabbba
baaa -> aabababaabbababaabbbabababaabbbabababaabbba

# < a,b | baababababaaba=a >
baababababaaba -> a
baabababaa -> abababaaba
baababaa -> abababaabababababaaba
baabaa -> abababaabababababaabababababaaba
baaa -> abababaabababababaabababababaabababababaaba

# < a,b | baabababababba=a >
baabababababba -> a
baabababababa -> aabababababba
baababababaa -> aabababababa
baabababaa -> aababababababababababba
baababaa -> aababababababababababbabababababba
baabaa -> aababababababababababbabababababbabababababba
baaa -> aababababababababababbabababababbabababababbabababababba

# < a,b | baababababbaba=a >
baababababbaba -> a
baababababbaa -> aababababbaba
baababababa -> aababababbabababababbaba
baabababaa -> aababababbabababababbaa
baababaa -> aababababbabababababa
baabaa -> aababababbabababababababababbaba
baaa -> aababababbabababababababababbabababababbaba

# < a,b | baababababbbba=a >
baababababbbba -> a
baababababbba -> aababababbbba
baababababba -> aababababbba
baababababa -> aababababba
baabababaa -> aababababa
baababaa -> aababababababababbbba
baabaa -> aababababababababbbbababababbbba
baaa -> aababababababababbbbababababbbbababababbbba

# < a,b | baabababbaabba=a >
baabababbaabba -> a
baabababbaaba -> aabababbaabba
baabababa -> aabababbaabbababbaabba
baababaa -> aabababbaabbababbaaba
baabaa -> aabababbaabbabaababbaabbabbaabba
baaa -> aabababbaabbabaababbaabbabbaabbabababbaabba

# < a,b | baabababbababa=a >
baabababbababa -> a
baabababbabaa -> aabababbababa
baabababbaa -> aabababbabababababbababa
baabababa -> aabababbabababababbabababababbababa
baababaa -> aabababbabababababbabababababbabaa
baabaa -> aabababbabababababbabababababbaa
baaa -> aabababbabababababbabababababa

# < a,b | baabababbabbba=a >
baabababbabbba -> a
baabababbabba -> aabababbabbba
baabababbaba -> aabababbabba
baabababbaa -> aabababbaba
baabababa -> aabababbababababbabbba
baababaa -> aabababbababababbabba
baabaa -> aabababbababababbabbabababbabbba
baaa -> aabababbababababbabbabababbabbbabababbabbba

# < a,b | baabababbbabba=a >
baabababbbabba -> a
baabababbbaba -> aabababbbabba
baabababbbaa -> aabababbbaba
baabababba -> aabababbbababababbbabba
baabababa -> aabababbbababababbbaba
baababaa -> aabababbbababababbbaa
baabaa -> aabababbbababababba
baaa -> aabababbbababababbabababbbabba

# < a,b | baabababbbbbba=a >
baabababbbbbba -> a
baabababbbbba -> aabababbbbbba
baabababbbba -> aabababbbbba
baabababbba -> aabababbbba
baabababba -> aabababbba
baabababa -> aabababba
baababaa -> aabababa
baabaa -> aababababababbbbbba
baaa -> aababababababbbbbbabababbbbbba

# < a,b | baababbaaababa=a >
baababbaaababa -> a
baababbaaabaa -> aababbaaababa
baababbaaaa -> aababbaaababababbaaababa

# < a,b | baababbaaabbaa=a >
baababbaaabbaa -> a
baababbaaaba -> ababbaaabbaa
baababbaaaa -> ababbaaabbaaababbaaabbaa

# < a,b | baababbaababba=a >
baababbaababba -> a
baababa -> aababba
baabaa -> aababa
baaa -> aababababbaababba

# < a,b | baababbaabbaba=a >
baababbaabbaba -> a
baababbaabbaa -> aababbaabbaba
baababbaaba -> aababbaabbabababbaabbaba
baababa -> aababbaabbabababbaabbababbaabbaba
baabaa -> aababbaabbabababbaabbababbaabbaa
baaa -> aababbaabbabababbaabbababbaaba

# < a,b | baababbaabbbba=a >
baababbaabbbba -> a
baababbaabbba -> aababbaabbbba
baababbaabba -> aababbaabbba
baababbaaba -> aababbaabba
baababa -> aababbaabbabbaabbbba
baabaa -> aababbaabbabbaabbba
baaa -> aababbaabbabbaabbbababbaabbbba

# < a,b | baababbabababa=a >
baababbabababa -> a
baababbababaa -> aababbabababa
baababbabaa -> aababbabababababbabababa
baababbaa -> aababbabababababbabababababbabababa
baababa -> aababbabababababbabababababbabababababbabababa
baabaa -> aababbabababababbabababababbabababababbababaa
baaa -> aababbabababababbabababababbabababababbabaa

# < a,b | baababbababbba=a >
baababbababbba -> a
baababbababba -> aababbababbba
baababbababa -> aababbababba
baababbabaa -> aababbababa
baababbaa -> aababbababababbababbba
baababa -> aababbababababbababbbababbababbba
baabaa -> aababbababababbababbbababbababba
baaa -> aababbababababbababbbababbababbababbababbba

# < a,b | baababbabbabba=a >
baababbabbabba -> a
baababbabbaba -> aababbabbabba
baababbabbaa -> aababbabbaba
baababbaba -> aababbabbabababbabbabba
baababbaa -> aababbabbabababbabbaba
baababa -> aababbabbabababbabbabababbabbabba
baabaa -> aababbabbabababbabbabababbabbaba
baaa -> aababbabbabababbabbabababbabbabababbabbabba

# < a,b | baababbabbbbba=a >
baababbabbbbba -> a
baababbabbbba -> aababbabbbbba
baababbabbba -> aababbabbbba
baababbabba -> aababbabbba
baababbaba -> aababbabba
baababbaa -> aababbaba
baababa -> aababbabababbabbbbba
baabaa -> aababbabababbabbbba
baaa -> aababbabababbabbbbababbabbbbba

# < a,b | baababbbaababa=a >
baababbbaababa -> a
baababbbaabaa -> aababbbaababa
baababbbaaa -> aababbbaababababbbaababa

# < a,b | baababbbaabbba=a >
baababbbaabbba -> a
baababbbaabba -> aababbbaabbba
baababbbaaba -> aababbbaabba
baababba -> aababbbaabbabbbaabbba
baababa -> aababbbaabbabbbaabba
baabaa -> aababbbaabbabbbaaba
baaa -> aababbbaabbaabbbaabbabbbaabbba

# < a,b | baababbbababba=a >
baababbbababba -> a
baababbbababa -> aababbbababba
baababbbabaa -> aababbbababa
baababbbaa -> aababbbababababbbababba
baababba -> aababbbababababbbababbababbbababba
baababa -> aababbbababababbbababbababbbababa
baabaa -> aababbbababababbbababbababbbabaa
baaa -> aababbbababababbbababbababbbaa

# < a,b | baababbbabbbba=a >
baababbbabbbba -> a
baababbbabbba -> aababbbabbbba
baababbbabba -> aababbbabbba
baababbbaba -> aababbbabba
baababbbaa -> aababbbaba
baababba -> aababbbabababbbabbbba
baababa -> aababbbabababbbabbba
baabaa -> aababbbabababbbabba
baaa -> aababbbabababbbabbababbbabbbba

# < a,b | baababbbbabbba=a >
baababbbbabbba -> a
baababbbbabba -> aababbbbabbba
baababbbbaba -> aababbbbabba
baababbbbaa -> aababbbbaba
baababbba -> aababbbbabababbbbabbba
baababba -> aababbbbabababbbbabba
baababa -> aababbbbabababbbbaba
baabaa -> aababbbbabababbbbaa
baaa -> aababbbbabababbba

# < a,b | baababbbbbbbba=a >
baababbbbbbbba -> a
baababbbbbbba -> aababbbbbbbba
baababbbbbba -> aababbbbbbba
baababbbbba -> aababbbbbba
baababbbba -> aababbbbba
baababbba -> aababbbba
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbbbbbbba

# < a,b | baabbaaaaababa=a >
baabbaaaaababa -> a
baabbaaaaabaa -> aabbaaaaababa
baabbaaaaaa -> aabbaaaaabababbaaaaababa

# < a,b | baabbaaaaabbaa=a >
baabbaaaaabbaa -> a
baabbaaaaaba -> abbaaaaabbaa
baabbaaaaaa -> abbaaaaabbaaabbaaaaabbaa

# < a,b | baabbaaaababba=a >
baabbaaaababba -> a
baabbaaaababa -> aabbaaaababba
baabbaaaabaa -> aabbaaaababa
baabbaaaaa -> aabbaaaabababbaaaababba

# < a,b | baabbaaaabbaba=a >
baabbaaaabbaba -> a
baabbaaaabbaa -> aabbaaaabbaba
baabbaaaaba -> aabbaaaabbababbaaaabbaba
baabbaaaaa -> aabbaaaabbababbaaaabbaa

# < a,b | baabbaaaabbbaa=a >
baabbaaaabbbaa -> a
baabbaaaabba -> abbaaaabbbaa
baabbaaaaba -> abbaaaabbbaaabbaaaabbbaa
baabbaaaaa -> abbaaaabbbaaabbaaaabbbaaabbaaaabbbaa

# < a,b | baabbaaabababa=a >
baabbaaabababa -> a
baabbaaababaa -> aabbaaabababa
baabbaaabaa -> aabbaaababababbaaabababa
baabbaaaa -> aabbaaababababbaaababababbaaabababa

# < a,b | baabbaaababbaa=a >
baabbaaababbaa -> a
baabbaaababa -> abbaaababbaa
baabbaaabaa -> abbaaababbaaabbaaababbaa
baabbaaaa -> abbaaababbaaabbaaababa

# < a,b | baabbaaababbba=a >
baabbaaababbba -> a
baabbaaababba -> aabbaaababbba
baabbaaababa -> aabbaaababba
baabbaaabaa -> aabbaaababa
baabbaaaa -> aabbaaabababbaaababbba

# < a,b | baabbaaabbabaa=a >
baabbaaabbabaa -> a
baabbaaabbaa -> abbaaabbabaa
baabbaaaba -> abbaaabbaa
baabbaaaa -> abbaaabbaaabbaaabbabaa

# < a,b | baabbaaabbabba=a >
baabbaaabbabba -> a
baabbaaabbaba -> aabbaaabbabba
baabbaaabbaa -> aabbaaabbaba
baabbaaaba -> aabbaaabbababbaaabbabba
baabbaaaa -> aabbaaabbababbaaabbaba

# < a,b | baabbaaabbbaba=a >
baabbaaabbbaba -> a
baabbaaabbbaa -> aabbaaabbbaba
baabbaaabba -> aabbaaabbbababbaaabbbaba
baabbaaaba -> aabbaaabbbababbaaabbbaa
baabbaaaa -> aabbaaabbbababbaaabbbaaabbaaabbbaba

# < a,b | baabbaaabbbbaa=a >
baabbaaabbbbaa -> a
baabbaaabbba -> abbaaabbbbaa
baabbaaabba -> abbaaabbbbaaabbaaabbbbaa
baabbaaaba -> abbaaabbbbaaabbaaabbbbaaabbaaabbbbaa
baabbaaaa -> abbaaabbbbaaabbaaabbbbaaabbaaabbbbaaabbaaabbbbaa

# < a,b | baabbaabaababa=a >
baabbaabaababa -> a
baabbaabaabaa -> aabbaabaababa
baabbaabaaa -> aabbaabaabababbaabaababa

# < a,b | baabbaabaabbba=a >
baabbaabaabbba -> a
baabbaabaabba -> aabbaabaabbba
baabbaabaaba -> aabbaabaabba
baabbaaa -> aabbaabaabbbaabaabbba
baabbaabaaa -> aabbaabaaba

# < a,b | baabbaabababba=a >
baabbaabababba -> a
baabbaabababa -> aabbaabababba
baabbaababaa -> aabbaabababa
baabbaabaa -> aabbaababababbaabababba
baabbaaa -> aabbaababababbaabababbabbaabababba

# < a,b | baabbaababbaba=a >
baabbaababbaba -> a
baabbaababbaa -> aabbaababbaba
baabbaababa -> aabbaababbababbaababbaba
baabbaabaa -> aabbaababbababbaababbaa
baabbaaa -> aabbaababbababbaababa

# < a,b | baabbaababbbaa=a >
baabbaababbbaa -> a
baabbaababba -> abbaababbbaa
baabbaababa -> abbaababbbaaabbaababbbaa
baabbaabaa -> abbaababbbaaabbaababbbaaabbaababbbaa
baabbaaa -> abbaababbbaaabbaababbbaaabbaababba

# < a,b | baabbaababbbba=a >
baabbaababbbba -> a
baabbaababbba -> aabbaababbbba
baabbaababba -> aabbaababbba
baabbaababa -> aabbaababba
baabbaabaa -> aabbaababa
baabbaaa -> aabbaabababbaababbbba

# < a,b | baabbaabbababa=a >
baabbaabbababa -> a
baabbaabbabaa -> aabbaabbababa
baabbaabbaa -> aabbaabbabababbaabbababa
baaba -> aabbaabbabababbaabbabababbababa
baaa -> aabbaabbabababbaabbabababbabaa

# < a,b | baabbaabbabbba=a >
baabbaabbabbba -> a
baabbaabbabba -> aabbaabbabbba
baabbaabbaba -> aabbaabbabba
baabbaabbaa -> aabbaabbaba
baaba -> aabbaabbababbabbba
baaa -> aabbaabbababbabba

# < a,b | baabbaabbbabba=a >
baabbaabbbabba -> a
baabbaabbbaba -> aabbaabbbabba
baabbaabbbaa -> aabbaabbbaba
baabbaabba -> aabbaabbbababbaabbbabba
baaba -> aabbaabbbababbaabbbabbaabbbabba
baaa -> aabbaabbbababbaabbbabbaabbbaba

# < a,b | baabbaabbbbbba=a >
baabbaabbbbbba -> a
baabbaabbbbba -> aabbaabbbbbba
baabbaabbbba -> aabbaabbbbba
baabbaabbba -> aabbaabbbba
baabbaabba -> aabbaabbba
baaba -> aabbaabbbaabbbbbba
baaa -> aabbaabbbaabbbbba

# < a,b | baabbabaaababa=a >
baabbabaaababa -> a
baabbabaaabaa -> aabbabaaababa
baabbabaaaa -> aabbabaaabababbabaaababa

# < a,b | baabbabaaabbaa=a >
baabbabaaabbaa -> a
baabbabaaaba -> abbabaaabbaa
baabbabaaaa -> abbabaaabbaaabbabaaabbaa

# < a,b | baabbabaababba=a >
baabbabaababba -> a
baabbabaababa -> aabbabaababba
baabbabaabaa -> aabbabaababa
baabbabaaa -> aabbabaabababbabaababba

# < a,b | baabbabaabbbba=a >
baabbabaabbbba -> a
baabbabaabbba -> aabbabaabbbba
baabbabaabba -> aabbabaabbba
baabbaa -> aabbabaabbbabaabbbba
baaba -> aabbabaabbbabaabbbbabbabaabbbba
baaa -> aabbabaabbbabaabbbbabbabaabbba

# < a,b | baabbababababa=a >
baabbababababa -> a
baabbabababaa -> aabbababababa
baabbababaa -> aabbabababababbababababa
baabbabaa -> aabbabababababbabababababbababababa
baabbaa -> aabbabababababbabababababbabababababbababababa
baaba -> aabbabababababbabababababbabababababbabababababbababababa
baaa -> aabbabababababbabababababbabababababbabababababbabababaa

# < a,b | baabbabababbba=a >
baabbabababbba -> a
baabbabababba -> aabbabababbba
baabbabababa -> aabbabababba
baabbababaa -> aabbabababa
baabbabaa -> aabbababababbabababbba
baabbaa -> aabbababababbabababbbabbabababbba
baaba -> aabbababababbabababbbabbabababbbabbabababbba
baaa -> aabbababababbabababbbabbabababbbabbabababba

# < a,b | baabbababbabba=a >
baabbababbabba -> a
baabbababbaba -> aabbababbabba
baabbababbaa -> aabbababbaba
baabbababa -> aabbababbababbababbabba
baabbabaa -> aabbababbababbababbaba
baabbaa -> aabbababbababbababbababbababbabba
baaba -> aabbababbababbababbababbababbabbabbababbabba
baaa -> aabbababbababbababbababbababbabbabbababbaba

# < a,b | baabbababbbbba=a >
baabbababbbbba -> a
baabbababbbba -> aabbababbbbba
baabbababbba -> aabbababbbba
baabbababba -> aabbababbba
baabbababa -> aabbababba
baabbabaa -> aabbababa
baabbaa -> aabbabababbababbbbba
baaba -> aabbabababbababbbbbabbababbbbba
baaa -> aabbabababbababbbbbabbababbbba

# < a,b | baabbabbaababa=a >
baabbabbaababa -> a
baabbabbaabaa -> aabbabbaababa
baabbabbaaa -> aabbabbaabababbabbaababa

# < a,b | baabbabbaabbaa=a >
baabbabbaabbaa -> a
baabbabbaaba -> abbabbaabbaa
baabbabbaaa -> abbabbaabbaaabbabbaabbaa

# < a,b | baabbabbaabbba=a >
baabbabbaabbba -> a
baabbabbaabba -> aabbabbaabbba
baabbaba -> aabbabbaabbbabbaabbba
baabbaa -> aabbabbaabbbabbaabba
baaba -> aabbabbaabbbabbaabbabbabbaabbba
baaa -> aabbabbaabbbabbaabbabbabbaabba

# < a,b | baabbabbababba=a >
baabbabbababba -> a
baabbabbababa -> aabbabbababba
baabbabbabaa -> aabbabbababa
baabbabbaa -> aabbabbabababbabbababba
baabbaba -> aabbabbabababbabbababbabbabbababba
baabbaa -> aabbabbabababbabbababbabbabbababa
baaba -> aabbabbabababbabbababbabbabbabababbabbababba
baaa -> aabbabbabababbabbababbabbabbabababbabbababa

# < a,b | baabbabbabbaba=a >
baabbabbabbaba -> a
baabbabbabbaa -> aabbabbabbaba
baabbabbaba -> aabbabbabbababbabbabbaba
baabbabbaa -> aabbabbabbababbabbabbaa
baabbaba -> aabbabbabbababbabbaba
baabbaa -> aabbabbabbababbabbaa
baaba -> aabbabbabbababbaba
baaa -> aabbabbabbababbaa

# < a,b | baabbabbabbbba=a >
baabbabbabbbba -> a
baabbabbabbba -> aabbabbabbbba
baabbabbabba -> aabbabbabbba
baabbabbaba -> aabbabbabba
baabbabbaa -> aabbabbaba
baabbaba -> aabbabbababbabbabbbba
baabbaa -> aabbabbababbabbabbba
baaba -> aabbabbababbabbabbbabbabbabbbba
baaa -> aabbabbababbabbabbbabbabbabbba

# < a,b | baabbabbbabbba=a >
baabbabbbabbba -> a
baabbabbbabba -> aabbabbbabbba
baabbabbbaba -> aabbabbbabba
baabbabbbaa -> aabbabbbaba
baabbabba -> aabbabbbababbabbbabbba
baabbaba -> aabbabbbababbabbbabba
baabbaa -> aabbabbbababbabbbaba
baaba -> aabbabbbababbabbbababbabbbabbba
baaa -> aabbabbbababbabbbababbabbbabba

# < a,b | baabbabbbbbbba=a >
baabbabbbbbbba -> a
baabbabbbbbba -> aabbabbbbbbba
baabbabbbbba -> aabbabbbbbba
baabbabbbba -> aabbabbbbba
baabbabbba -> aabbabbbba
baabbabba -> aabbabbba
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabbbbbbba
baaa -> aabbababbabbbbbba

# < a,b | baabbbaaaababa=a >
baabbbaaaababa -> a
baabbbaaaabaa -> aabbbaaaababa
baabbbaaaaa -> aabbbaaaabababbbaaaababa

# < a,b | baabbbaaaabbaa=a >
baabbbaaaabbaa -> a
baabbbaaaaba -> abbbaaaabbaa
baabbbaaaaa -> abbbaaaabbaaabbbaaaabbaa

# < a,b | baabbbaaababba=a >
baabbbaaababba -> a
baabbbaaababa -> aabbbaaababba
baabbbaaabaa -> aabbbaaababa
baabbbaaaa -> aabbbaaabababbbaaababba

# < a,b | baabbbaaabbaba=a >
baabbbaaabbaba -> a
baabbbaaabbaa -> aabbbaaabbaba
baabbbaaaba -> aabbbaaabbababbbaaabbaba
baabbbaaaa -> aabbbaaabbababbbaaabbaa

# < a,b | baabbbaaabbbaa=a >
baabbbaaabbbaa -> a
baabbbaaabba -> abbbaaabbbaa
baabbbaaaba -> abbbaaabbbaaabbbaaabbbaa
baabbbaaaa -> abbbaaabbbaaabbbaaabbbaaabbbaaabbbaa

# < a,b | baabbbaabababa=a >
baabbbaabababa -> a
baabbbaababaa -> aabbbaabababa
baabbbaabaa -> aabbbaababababbbaabababa
baabbbaaa -> aabbbaababababbbaababababbbaabababa

# < a,b | baabbbaababbaa=a >
baabbbaababbaa -> a
baabbbaababa -> abbbaababbaa
baabbbaabaa -> abbbaababbaaabbbaababbaa
baabbbaaa -> abbbaababbaaabbbaababa

# < a,b | baabbbaababbba=a >
baabbbaababbba -> a
baabbbaababba -> aabbbaababbba
baabbbaababa -> aabbbaababba
baabbbaabaa -> aabbbaababa
baabbbaaa -> aabbbaabababbbaababbba

# < a,b | baabbbaabbabaa=a >
baabbbaabbabaa -> a
baabbbaabbaa -> abbbaabbabaa
baabbbaaba -> abbbaabbaa
baabbbaaa -> abbbaabbaaabbbaabbabaa

# < a,b | baabbbaabbabba=a >
baabbbaabbabba -> a
baabbbaabbaba -> aabbbaabbabba
baabbbaabbaa -> aabbbaabbaba
baabbbaaba -> aabbbaabbababbbaabbabba
baabbbaaa -> aabbbaabbababbbaabbaba

# < a,b | baabbbaabbbbba=a >
baabbbaabbbbba -> a
baabbbaabbbba -> aabbbaabbbbba
baabbbaabbba -> aabbbaabbbba
baabba -> aabbbaabbbbaabbbbba
baaba -> aabbbaabbbbaabbbba
baaa -> aabbbaabbbbaabbba

# < a,b | baabbbabaababa=a >
baabbbabaababa -> a
baabbbabaabaa -> aabbbabaababa
baabbbabaaa -> aabbbabaabababbbabaababa

# < a,b | baabbbabaabbaa=a >
baabbbabaabbaa -> a
baabbbabaaba -> abbbabaabbaa
baabbbabaaa -> abbbabaabbaaabbbabaabbaa

# < a,b | baabbbabababba=a >
baabbbabababba -> a
baabbbabababa -> aabbbabababba
baabbbababaa -> aabbbabababa
baabbbabaa -> aabbbababababbbabababba
baabbbaa -> aabbbababababbbabababbabbbabababba
baabba -> aabbbababababbbabababbabbbabababbabbbabababba
baaba -> aabbbababababbbabababbabbbabababbabbbabababa
baaa -> aabbbababababbbabababbabbbabababbabbbababaa

# < a,b | baabbbababbbba=a >
baabbbababbbba -> a
baabbbababbba -> aabbbababbbba
baabbbababba -> aabbbababbba
baabbbababa -> aabbbababba
baabbbabaa -> aabbbababa
baabbbaa -> aabbbabababbbababbbba
baabba -> aabbbabababbbababbbbabbbababbbba
baaba -> aabbbabababbbababbbbabbbababbba
baaa -> aabbbabababbbababbbbabbbababba

# < a,b | baabbbabbabbba=a >
baabbbabbabbba -> a
baabbbabbabba -> aabbbabbabbba
baabbbabbaba -> aabbbabbabba
baabbbabbaa -> aabbbabbaba
baabbbaba -> aabbbabbababbbabbabbba
baabbbaa -> aabbbabbababbbabbabba
baabba -> aabbbabbababbbabbabbabbbabbabbba
baaba -> aabbbabbababbbabbabbabbbabbabba
baaa -> aabbbabbababbbabbabbabbbabbaba

# < a,b | baabbbabbbabba=a >
baabbbabbbabba -> a
baabbbabbbaba -> aabbbabbbabba
baabbbabbbaa -> aabbbabbbaba
baabbbabba -> aabbbabbbababbbabbbabba
baabbbaba -> aabbbabbbababbbabbbaba
baabbbaa -> aabbbabbbababbbabbbaa
baabba -> aabbbabbbababbbabba
baaba -> aabbbabbbababbbaba
baaa -> aabbbabbbababbbaa

# < a,b | baabbbabbbbbba=a >
baabbbabbbbbba -> a
baabbbabbbbba -> aabbbabbbbbba
baabbbabbbba -> aabbbabbbbba
baabbbabbba -> aabbbabbbba
baabbbabba -> aabbbabbba
baabbbaba -> aabbbabba
baabbbaa -> aabbbaba
baabba -> aabbbababbbabbbbbba
baaba -> aabbbababbbabbbbba
baaa -> aabbbababbbabbbba

# < a,b | baabbbbaaababa=a >
baabbbbaaababa -> a
baabbbbaaabaa -> aabbbbaaababa
baabbbbaaaa -> aabbbbaaabababbbbaaababa

# < a,b | baabbbbaaabbaa=a >
baabbbbaaabbaa -> a
baabbbbaaaba -> abbbbaaabbaa
baabbbbaaaa -> abbbbaaabbaaabbbbaaabbaa

# < a,b | baabbbbaababba=a >
baabbbbaababba -> a
baabbbbaababa -> aabbbbaababba
baabbbbaabaa -> aabbbbaababa
baabbbbaaa -> aabbbbaabababbbbaababba

# < a,b | baabbbbaabbaba=a >
baabbbbaabbaba -> a
baabbbbaabbaa -> aabbbbaabbaba
baabbbbaaba -> aabbbbaabbababbbbaabbaba
baabbbbaaa -> aabbbbaabbababbbbaabbaa

# < a,b | baabbbbaabbbaa=a >
baabbbbaabbbaa -> a
baabbbbaabba -> abbbbaabbbaa
baabbbbaaba -> abbbbaabbbaaabbbbaabbbaa
baabbbbaaa -> abbbbaabbbaaabbbbaabbbaaabbbbaabbbaa

# < a,b | baabbbbababbba=a >
baabbbbababbba -> a
baabbbbababba -> aabbbbababbba
baabbbbababa -> aabbbbababba
baabbbbabaa -> aabbbbababa
baabbbbaa -> aabbbbabababbbbababbba
baabbba -> aabbbbabababbbbababbbabbbbababbba
baabba -> aabbbbabababbbbababbbabbbbababba
baaba -> aabbbbabababbbbababbbabbbbababa
baaa -> aabbbbabababbbbababbbabbbbabaa

# < a,b | baabbbbabbbbba=a >
baabbbbabbbbba -> a
baabbbbabbbba -> aabbbbabbbbba
baabbbbabbba -> aabbbbabbbba
baabbbbabba -> aabbbbabbba
baabbbbaba -> aabbbbabba
baabbbbaa -> aabbbbaba
baabbba -> aabbbbababbbbabbbbba
baabba -> aabbbbababbbbabbbba
baaba -> aabbbbababbbbabbba
baaa -> aabbbbababbbbabba

# < a,b | baabbbbbaababa=a >
baabbbbbaababa -> a
baabbbbbaabaa -> aabbbbbaababa
baabbbbbaaa -> aabbbbbaabababbbbbaababa

# < a,b | baabbbbbaabbaa=a >
baabbbbbaabbaa -> a
baabbbbbaaba -> abbbbbaabbaa
baabbbbbaaa -> abbbbbaabbaaabbbbbaabbaa

# < a,b | baabbbbbabbbba=a >
baabbbbbabbbba -> a
baabbbbbabbba -> aabbbbbabbbba
baabbbbbabba -> aabbbbbabbba
baabbbbbaba -> aabbbbbabba
baabbbbbaa -> aabbbbbaba
baabbbba -> aabbbbbababbbbbabbbba
baabbba -> aabbbbbababbbbbabbba
baabba -> aabbbbbababbbbbabba
baaba -> aabbbbbababbbbbaba
baaa -> aabbbbbababbbbbaa

# < a,b | babaaaaaababba=a >
babaaaaaababba -> a
babaaaaaababa -> abaaaaaababba
babaaaaaabaa -> abaaaaaababa
babaaaaaaa -> abaaaaaababbaaaaaababba

# < a,b | babaaaaabababa=a >
babaaaaabababa -> a
babaaaaababaa -> abaaaaabababa
babaaaaabaa -> aaaaabababa
babaaaaaa -> abaaaaabababaaaabababa

# < a,b | babaaaaababbba=a >
babaaaaababbba -> a
babaaaaababba -> abaaaaababbba
babaaaaababa -> abaaaaababba
babaaaaabaa -> abaaaaababa
babaaaaaa -> abaaaaababbaaaaababbba

# < a,b | babaaaaabbabaa=a >
babaaaaabbabaa -> a
babaaaaaba -> aaaabbabaa
babaaaaaa -> aaaabbabaabaaaaabbabaa

# < a,b | babaaaaabbabba=a >
babaaaaabbabba -> a
babaaaaabbaba -> abaaaaabbabba
babaaaaabbaa -> abaaaaabbaba
babaaaaaba -> abaaaaabbabbaaaaabbabba
babaaaaaa -> abaaaaabbabbaaaaabbaba

# < a,b | babaaaaabbbaba=a >
babaaaaabbbaba -> a
babaaaaabbbaa -> abaaaaabbbaba
babaaaaabba -> aaaaabbbaba
babaaaaaba -> aaaaabbbaa
babaaaaaa -> aaaaabbbaabaaaaabbbaba

# < a,b | babaaaababaaba=a >
babaaaababaaba -> a
babaaaababaaa -> abaaaababaaba
babaaaaa -> abaaaababaabaababaaba

# < a,b | babaaaabababba=a >
babaaaabababba -> a
babaaaabababa -> abaaaabababba
babaaaababaa -> abaaaabababa
babaaaabaa -> abaaaabababbaaaabababba
babaaaaa -> abaaaabababaaabababba

# < a,b | babaaaababbbba=a >
babaaaababbbba -> a
babaaaababbba -> abaaaababbbba
babaaaababba -> abaaaababbba
babaaaababa -> abaaaababba
babaaaabaa -> abaaaababa
babaaaaa -> abaaaababbaaaababbbba

# < a,b | babaaaabbabaaa=a >
babaaaabbabaaa -> a
babaaaaba -> aabbabaaa
babaaaaa -> aabbabaaabaaaabbabaaa

# < a,b | babaaaabbababa=a >
babaaaabbababa -> a
babaaaabbabaa -> abaaaabbababa
babaaaabbaa -> aaaabbababa
babaaaaba -> abaaaabbababaaabbababa
babaaaaa -> abaaaabbababaaabbabaa

# < a,b | babaaaabbabbba=a >
babaaaabbabbba -> a
babaaaabbabba -> abaaaabbabbba
babaaaabbaba -> abaaaabbabba
babaaaabbaa -> abaaaabbaba
babaaaaba -> abaaaabbabbaaaabbabbba
babaaaaa -> abaaaabbabbaaaabbabba

# < a,b | babaaaabbbabaa=a >
babaaaabbbabaa -> a
babaaaabba -> aaabbbabaa
babaaaaba -> aaabbbabaabaaaabbbabaa
babaaaaa -> aaabbbabaabaaaabbbabaabaaaabbbabaa

# < a,b | babaaaabbbabba=a >
babaaaabbbabba -> a
babaaaabbbaba -> abaaaabbbabba
babaaaabbbaa -> abaaaabbbaba
babaaaabba -> abaaaabbbabbaaaabbbabba
babaaaaba -> abaaaabbbabbaaaabbbaba
babaaaaa -> abaaaabbbabbaaaabbbaa

# < a,b | babaaaabbbbaba=a >
babaaaabbbbaba -> a
babaaaabbbbaa -> abaaaabbbbaba
babaaaabbba -> aaaabbbbaba
babaaaabba -> aaaabbbbaa
babaaaaba -> aaaabbbbaabaaaabbbbaba
babaaaaa -> aaaabbbbaabaaaabbbbaa

# < a,b | babaaabaababba=a >
babaaabaababba -> a
babaaabaababa -> abaaabaababba
babaaabaabaa -> abaaabaababa
babaaabaaa -> abaaabaababbaaabaababba

# < a,b | babaaababaabba=a >
babaaababaabba -> a
babaaababaaba -> abaaababaabba
babaaababaaa -> abaaababaaba
babaaaa -> abaaababaabababaabba

# < a,b | babaaababababa=a >
babaaababababa -> a
babaaabababaa -> abaaababababa
babaaababaa -> aaababababa
babaaabaa -> abaaababababaababababa
babaaaa -> aaababababaababababa

# < a,b | babaaabababbba=a >
babaaabababbba -> a
babaaabababba -> abaaabababbba
babaaabababa -> abaaabababba
babaaababaa -> abaaabababa
babaaabaa -> abaaabababbaaabababbba
babaaaa -> abaaabababaabababbba

# < a,b | babaaababbabba=a >
babaaababbabba -> a
babaaababbaba -> abaaababbabba
babaaababbaa -> abaaababbaba
babaaababa -> abaaababbabbaaababbabba
babaaabaa -> abaaababbabbaaababbaba
babaaaa -> abaaababbabbaaababbabbaaababbabba

# < a,b | babaaababbbaba=a >
babaaababbbaba -> a
babaaababbbaa -> abaaababbbaba
babaaababba -> aaababbbaba
babaaababa -> aaababbbaa
babaaabaa -> aaababbbaabaaababbbaba
babaaaa -> aaababbbaaaababbbaba

# < a,b | babaaababbbbba=a >
babaaababbbbba -> a
babaaababbbba -> abaaababbbbba
babaaababbba -> abaaababbbba
babaaababba -> abaaababbba
babaaababa -> abaaababba
babaaabaa -> abaaababa
babaaaa -> abaaababbaaababbbbba

# < a,b | babaaabbabaaba=a >
babaaabbabaaba -> a
babaaabbabaaa -> abaaabbabaaba
babaaaba -> abaaabbabaababbabaaba
babaaaa -> abaaabbabaababbabaaa

# < a,b | babaaabbababba=a >
babaaabbababba -> a
babaaabbababa -> abaaabbababba
babaaabbabaa -> abaaabbababa
babaaabbaa -> abaaabbababbaaabbababba
babaaaba -> abaaabbababaabbababba
babaaaa -> abaaabbababaabbababa

# < a,b | babaaabbabbbba=a >
babaaabbabbbba -> a
babaaabbabbba -> abaaabbabbbba
babaaabbabba -> abaaabbabbba
babaaabbaba -> abaaabbabba
babaaabbaa -> abaaabbaba
babaaaba -> abaaabbabbaaabbabbbba
babaaaa -> abaaabbabbaaabbabbba

# < a,b | babaaabbbababa=a >
babaaabbbababa -> a
babaaabbbabaa -> abaaabbbababa
babaaabbbaa -> aaabbbababa
babaaabba -> abaaabbbababaabbbababa
babaaaba -> abaaabbbababaabbbabaa
babaaaa -> abaaabbbababaabbbabaabaaabbbababa

# < a,b | babaaabbbabbba=a >
babaaabbbabbba -> a
babaaabbbabba -> abaaabbbabbba
babaaabbbaba -> abaaabbbabba
babaaabbbaa -> abaaabbbaba
babaaabba -> abaaabbbabbaaabbbabbba
babaaaba -> abaaabbbabbaaabbbabba
babaaaa -> abaaabbbabbaaabbbaba

# < a,b | babaaabbbbabaa=a >
babaaabbbbabaa -> a
babaaabbba -> aabbbbabaa
babaaabba -> aabbbbabaabaaabbbbabaa
babaaaba -> aabbbbabaabaaabbbbabaabaaabbbbabaa
babaaaa -> aabbbbabaabaaabbbbabaabaaabbbbabaabaaabbbbabaa

# < a,b | babaaabbbbabba=a >
babaaabbbbabba -> a
babaaabbbbaba -> abaaabbbbabba
babaaabbbbaa -> abaaabbbbaba
babaaabbba -> abaaabbbbabbaaabbbbabba
babaaabba -> abaaabbbbabbaaabbbbaba
babaaaba -> abaaabbbbabbaaabbbbaa
babaaaa -> abaaabbbbabbaaabbbbaabaaabbbbabba

# < a,b | babaaabbbbbaba=a >
babaaabbbbbaba -> a
babaaabbbbbaa -> abaaabbbbbaba
babaaabbbba -> aaabbbbbaba
babaaabbba -> aaabbbbbaa
babaaabba -> aaabbbbbaabaaabbbbbaba
babaaaba -> aaabbbbbaabaaabbbbbaa
babaaaa -> aaabbbbbaabaaabbbbbaabaaabbbbbaba

# < a,b | babaabaaababba=a >
babaabaaababba -> a
babaabaaababa -> abaabaaababba
babaabaaabaa -> abaabaaababa
babaabaaaa -> abaabaaababbaabaaababba

# < a,b | babaabaabababa=a >
babaabaabababa -> a
babaabaababaa -> abaabaabababa
babaabaabaa -> aabaabababa
babaabaaa -> abaabaababababaabababa

# < a,b | babaabaababbba=a >
babaabaababbba -> a
babaabaababba -> abaabaababbba
babaabaababa -> abaabaababba
babaabaabaa -> abaabaababa
babaabaaa -> abaabaababbaabaababbba

# < a,b | babaabaabbabaa=a >
babaabaabbabaa -> a
babaabaaba -> abaabbabaa
babaabaaa -> abaababaabbabaaabbabaa

# < a,b | babaabaabbabba=a >
babaabaabbabba -> a
babaabaabbaba -> abaabaabbabba
babaabaabbaa -> abaabaabbaba
babaabaaba -> abaabaabbabbaabaabbabba
babaabaaa -> abaabaabbabbaabaabbaba

# < a,b | babaabaabbbaba=a >
babaabaabbbaba -> a
babaabaabbbaa -> abaabaabbbaba
babaabaabba -> aabaabbbaba
babaabaaba -> aabaabbbaa
babaabaaa -> aabaabbbaabaabaabbbaba

# < a,b | babaababaabbba=a >
babaababaabbba -> a
babaababaabba -> abaababaabbba
babaababaaba -> abaababaabba
babaaa -> abaababaabbabaabbba

# < a,b | babaababababba=a >
babaababababba -> a
babaababababa -> abaababababba
babaabababaa -> abaababababa
babaababaa -> abaababababbaababababba
babaabaa -> abaababababababababba
babaaa -> abaababababbaababababbababababba

# < a,b | babaabababbaba=a >
babaabababbaba -> a
babaabababbaa -> abaabababbaba
babaabababa -> aabababbaba
babaababaa -> aabababbaa
babaabaa -> aabababa
babaaa -> aabababbaabababbaba

# < a,b | babaabababbbba=a >
babaabababbbba -> a
babaabababbba -> abaabababbbba
babaabababba -> abaabababbba
babaabababa -> abaabababba
babaababaa -> abaabababa
babaabaa -> abaabababbaabababbbba
babaaa -> abaababababababbbba

# < a,b | babaababbababa=a >
babaababbababa -> a
babaababbabaa -> abaababbababa
babaababbaa -> aababbababa
babaababa -> abaababbababababbababa
babaabaa -> abaababbababababbabaa
babaaa -> abaababbababababbaa

# < a,b | babaababbabbba=a >
babaababbabbba -> a
babaababbabba -> abaababbabbba
babaababbaba -> abaababbabba
babaababbaa -> abaababbaba
babaababa -> abaababbabbaababbabbba
babaabaa -> abaababbabbaababbabba
babaaa -> abaababbabbaababbabbbaababbabbba

# < a,b | babaababbbabba=a >
babaababbbabba -> a
babaababbbaba -> abaababbbabba
babaababbbaa -> abaababbbaba
babaababba -> abaababbbabbaababbbabba
babaababa -> abaababbbabbaababbbaba
babaabaa -> abaababbbabbaababbbaa
babaaa -> abaababbbabbaababba

# < a,b | babaababbbbaba=a >
babaababbbbaba -> a
babaababbbbaa -> abaababbbbaba
babaababbba -> aababbbbaba
babaababba -> aababbbbaa
babaababa -> aababbbbaabaababbbbaba
babaabaa -> aababbbbaabaababbbbaa
babaaa -> aababbbbaabaababbba

# < a,b | babaababbbbbba=a >
babaababbbbbba -> a
babaababbbbba -> abaababbbbbba
babaababbbba -> abaababbbbba
babaababbba -> abaababbbba
babaababba -> abaababbba
babaababa -> abaababba
babaabaa -> abaababa
babaaa -> abaababbaababbbbbba

# < a,b | babaabbaababba=a >
babaabbaababba -> a
babaabbaababa -> abaabbaababba
babaabbaabaa -> abaabbaababa
babaabbaaa -> abaabbaababbaabbaababba

# < a,b | babaabbabababa=a >
babaabbabababa -> a
babaabbababaa -> abaabbabababa
babaabbabaa -> aabbabababa
babaabbaa -> abaabbababababbabababa
babaaba -> aabbababababbabababa
babaaa -> aabbababababbababaa

# < a,b | babaabbababbba=a >
babaabbababbba -> a
babaabbababba -> abaabbababbba
babaabbababa -> abaabbababba
babaabbabaa -> abaabbababa
babaabbaa -> abaabbababbaabbababbba
babaaba -> abaabbabababbababbba
babaaa -> abaabbabababbababba

# < a,b | babaabbabbabba=a >
babaabbabbabba -> a
babaabbabbaba -> abaabbabbabba
babaabbabbaa -> abaabbabbaba
babaabbaba -> abaabbabbabbaabbabbabba
babaabbaa -> abaabbabbabbaabbabbaba
babaaba -> abaabbabbabbaabbabbabbaabbabbabba
babaaa -> abaabbabbabbaabbabbabbaabbabbaba

# < a,b | babaabbabbbaba=a >
babaabbabbbaba -> a
babaabbabbbaa -> abaabbabbbaba
babaabbabba -> aabbabbbaba
babaabbaba -> aabbabbbaa
babaabbaa -> aabbabbbaabaabbabbbaba
babaaba -> aabbabbbaaabbabbbaba
babaaa -> aabbabbbaaabbabbbaa

# < a,b | babaabbabbbbba=a >
babaabbabbbbba -> a
babaabbabbbba -> abaabbabbbbba
babaabbabbba -> abaabbabbbba
babaabbabba -> abaabbabbba
babaabbaba -> abaabbabba
babaabbaa -> abaabbaba
babaaba -> abaabbabbaabbabbbbba
babaaa -> abaabbabbaabbabbbba

# < a,b | babaabbbababba=a >
babaabbbababba -> a
babaabbbababa -> abaabbbababba
babaabbbabaa -> abaabbbababa
babaabbbaa -> abaabbbababbaabbbababba
babaabba -> abaabbbabababbbababba
babaaba -> abaabbbabababbbababa
babaaa -> abaabbbabababbbabaa

# < a,b | babaabbbabbaba=a >
babaabbbabbaba -> a
babaabbbabbaa -> abaabbbabbaba
babaabbbaba -> aabbbabbaba
babaabbbaa -> aabbbabbaa
babaabba -> aabbbaba
babaaba -> aabbbaa
babaaa -> aabbbaabaabbbabbaba

# < a,b | babaabbbabbbba=a >
babaabbbabbbba -> a
babaabbbabbba -> abaabbbabbbba
babaabbbabba -> abaabbbabbba
babaabbbaba -> abaabbbabba
babaabbbaa -> abaabbbaba
babaabba -> abaabbbabbaabbbabbbba
babaaba -> abaabbbabbaabbbabbba
babaaa -> abaabbbabbaabbbabba

# < a,b | babaabbbbabbba=a >
babaabbbbabbba -> a
babaabbbbabba -> abaabbbbabbba
babaabbbbaba -> abaabbbbabba
babaabbbbaa -> abaabbbbaba
babaabbba -> abaabbbbabbaabbbbabbba
babaabba -> abaabbbbabbaabbbbabba
babaaba -> abaabbbbabbaabbbbaba
babaaa -> abaabbbbabbaabbbbaa

# < a,b | babaabbbbbabba=a >
babaabbbbbabba -> a
babaabbbbbaba -> abaabbbbbabba
babaabbbbbaa -> abaabbbbbaba
babaabbbba -> abaabbbbbabbaabbbbbabba
babaabbba -> abaabbbbbabbaabbbbbaba
babaabba -> abaabbbbbabbaabbbbbaa
babaaba -> abaabbbbbabbaabbbbbaabaabbbbbabba
babaaa -> abaabbbbbabbaabbbbbaabaabbbbbaba

# < a,b | babaabbbbbbaba=a >
babaabbbbbbaba -> a
babaabbbbbbaa -> abaabbbbbbaba
babaabbbbba -> aabbbbbbaba
babaabbbba -> aabbbbbbaa
babaabbba -> aabbbbbbaabaabbbbbbaba
babaabba -> aabbbbbbaabaabbbbbbaa
babaaba -> aabbbbbbaabaabbbbbbaabaabbbbbbaba
babaaa -> aabbbbbbaabaabbbbbbaabaabbbbbbaa

# < a,b | bababaaaababba=a >
bababaaaababba -> a
bababaaaababa -> ababaaaababba
bababaaaabaa -> ababaaaababa
bababaaaaa -> ababaaaababbabaaaababba

# < a,b | bababaaababbba=a >
bababaaababbba -> a
bababaaababba -> ababaaababbba
bababaaababa -> ababaaababba
bababaaabaa -> ababaaababa
bababaaaa -> ababaaababbabaaababbba

# < a,b | bababaaabbabba=a >
bababaaabbabba -> a
bababaaabbaba -> ababaaabbabba
bababaaabbaa -> ababaaabbaba
bababaaaba -> ababaaabbabbabaaabbabba
bababaaaa -> ababaaabbabbabaaabbaba

# < a,b | bababaaabbbaba=a >
bababaaabbbaba -> a
bababaaabbbaa -> ababaaabbbaba
bababaaabba -> abaaabbbaba
bababaaaba -> abaaabbbaa
bababaaaa -> abaaabbbaababaaabbbaba

# < a,b | bababaabababba=a >
bababaabababba -> a
bababaabababa -> ababaabababba
bababaababaa -> ababaabababa
bababaabaa -> ababaabababbabaabababba
bababaaa -> ababaabababbaabababba

# < a,b | bababaababbbba=a >
bababaababbbba -> a
bababaababbba -> ababaababbbba
bababaababba -> ababaababbba
bababaababa -> ababaababba
bababaabaa -> ababaababa
bababaaa -> ababaababbabaababbbba

# < a,b | bababaabbabbba=a >
bababaabbabbba -> a
bababaabbabba -> ababaabbabbba
bababaabbaba -> ababaabbabba
bababaabbaa -> ababaabbaba
bababaaba -> ababaabbabbabaabbabbba
bababaaa -> ababaabbabbabaabbabba

# < a,b | bababaabbbabba=a >
bababaabbbabba -> a
bababaabbbaba -> ababaabbbabba
bababaabbbaa -> ababaabbbaba
bababaabba -> ababaabbbabbabaabbbabba
bababaaba -> ababaabbbabbabaabbbaba
bababaaa -> ababaabbbabbabaabbbaa

# < a,b | bababaabbbbaba=a >
bababaabbbbaba -> a
bababaabbbbaa -> ababaabbbbaba
bababaabbba -> abaabbbbaba
bababaabba -> abaabbbbaa
bababaaba -> abaabbbbaababaabbbbaba
bababaaa -> abaabbbbaababaabbbbaa

# < a,b | babababaababba=a >
babababaababba -> a
babababaababa -> abababaababba
babababaabaa -> abababaababa
babababaaa -> abababaababbababaababba

# < a,b | babababababbba=a >
babababababbba -> a
babababababba -> abababababbba
babababababa -> abababababba
baa -> abababababbabbba

# < a,b | bababababbabba=a >
bababababbabba -> a
bababababbaba -> ababababbabba
bababababa -> ababababbabbabababbabba
baa -> ababababbabbabababbabbabbabba

# < a,b | bababababbbbba=a >
bababababbbbba -> a
bababababbbba -> ababababbbbba
bababababbba -> ababababbbba
bababababba -> ababababbba
bababababa -> ababababba
baa -> ababababbabbbbba

# < a,b | babababbababba=a >
babababbababba -> a
babababbababa -> abababbababba
babababa -> abababbababbabbababba
baa -> abababbababbabbababbabbababba

# < a,b | babababbabbaba=a >
babababbabbaba -> a
babababbaba -> ababbabbaba
babababa -> ababbaba
baa -> ababbababbabbaba

# < a,b | babababbabbbba=a >
babababbabbbba -> a
babababbabbba -> abababbabbbba
babababbabba -> abababbabbba
babababbaba -> abababbabba
babababa -> abababbabbababbabbbba
baa -> abababbabbababbabbbbabbabbbba

# < a,b | babababbbabbba=a >
babababbbabbba -> a
babababbbabba -> abababbbabbba
babababbbaba -> abababbbabba
babababba -> abababbbabbababbbabbba
babababa -> abababbbabbababbbabba
baa -> abababbbabbababbbabbabbbabbba

# < a,b | babababbbbbbba=a >
babababbbbbbba -> a
babababbbbbba -> abababbbbbbba
babababbbbba -> abababbbbbba
babababbbba -> abababbbbba
babababbba -> abababbbba
babababba -> abababbba
babababa -> abababba
baa -> abababbabbbbbbba

# < a,b | bababbaaababba=a >
bababbaaababba -> a
bababbaaababa -> ababbaaababba
bababbaaabaa -> ababbaaababa
bababbaaaa -> ababbaaababbabbaaababba

# < a,b | bababbaababbba=a >
bababbaababbba -> a
bababbaababba -> ababbaababbba
bababbaababa -> ababbaababba
bababbaabaa -> ababbaababa
bababbaaa -> ababbaababbabbaababbba

# < a,b | bababbaabbabba=a >
bababbaabbabba -> a
bababbaabbaba -> ababbaabbabba
bababbaabbaa -> ababbaabbaba
bababbaaba -> ababbaabbabbabbaabbabba
bababbaaa -> ababbaabbabbabbaabbaba

# < a,b | bababbaabbbaba=a >
bababbaabbbaba -> a
bababbaabbbaa -> ababbaabbbaba
bababbaabba -> abbaabbbaba
bababbaaba -> abbaabbbaa
bababbaaa -> abbaabbbaababbaabbbaba

# < a,b | bababbabababba=a >
bababbabababba -> a
bababbabababa -> ababbabababba
bababbaa -> abababba
bababbababaa -> ababbabababa
bababbabaa -> ababbabababbabbabababba

# < a,b | bababbababbbba=a >
bababbababbbba -> a
bababbababbba -> ababbababbbba
bababbababba -> ababbababbba
bababa -> ababbababbbababbbba
baa -> ababbababbbababbbbabbababbbba

# < a,b | bababbabbabbba=a >
bababbabbabbba -> a
bababbabbabba -> ababbabbabbba
bababbabbaba -> ababbabbabba
bababbaba -> ababbabbabbabbabbabbba
bababa -> ababbabbabbabbabbabbbabbabbabbba
baa -> ababbabbabbabbabbabbbabbabbabbbabbabbabbba

# < a,b | bababbabbbabba=a >
bababbabbbabba -> a
bababbabbbaba -> ababbabbbabba
bababbabba -> ababbabbbabbabbabbbabba
bababbaba -> ababbabbbabbabbabbbaba
bababa -> ababbabbbabbabbabba
baa -> ababbabbbabbabbabbabbabbbabba

# < a,b | bababbabbbbbba=a >
bababbabbbbbba -> a
bababbabbbbba -> ababbabbbbbba
bababbabbbba -> ababbabbbbba
bababbabbba -> ababbabbbba
bababbabba -> ababbabbba
bababbaba -> ababbabba
bababa -> ababbabbabbabbbbbba
baa -> ababbabbabbabbbbbbabbabbbbbba

# < a,b | bababbbaababba=a >
bababbbaababba -> a
bababbbaababa -> ababbbaababba
bababbbaabaa -> ababbbaababa
bababbbaaa -> ababbbaababbabbbaababba

# < a,b | bababbbababbba=a >
bababbbababbba -> a
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbababbba

# < a,b | bababbbabbabba=a >
bababbbabbabba -> a
bababbbabbaba -> ababbbabbabba
bababbbaba -> ababbbabbabbabbbabbabba
bababba -> ababbbabbabbabbbabbabbabbbabbabba
bababa -> ababbbabbabbabbbabbabbabbbabbaba
baa -> ababbbabbabbabbbabbabbabbbaba

# < a,b | bababbbabbbbba=a >
bababbbabbbbba -> a
bababbbabbbba -> ababbbabbbbba
bababbbabbba -> ababbbabbbba
bababbbabba -> ababbbabbba
bababbbaba -> ababbbabba
bababba -> ababbbabbabbbabbbbba
bababa -> ababbbabbabbbabbbba
baa -> ababbbabbabbbabbbbabbbabbbbba

# < a,b | bababbbbababba=a >
bababbbbababba -> a
bababbbbababa -> ababbbbababba
bababbbbabaa -> ababbbbababa
bababbbbaa -> ababbbbababbabbbbababba

# < a,b | bababbbbabbbba=a >
bababbbbabbbba -> a
bababbbbabbba -> ababbbbabbbba
bababbbbabba -> ababbbbabbba
bababbbbaba -> ababbbbabba
bababbba -> ababbbbabbabbbbabbbba
bababba -> ababbbbabbabbbbabbba
bababa -> ababbbbabbabbbbabba
baa -> ababbbbabbabbbbabbabbbbabbbba

# < a,b | bababbbbbbbbba=a >
bababbbbbbbbba -> a
bababbbbbbbba -> ababbbbbbbbba
bababbbbbbba -> ababbbbbbbba
bababbbbbba -> ababbbbbbba
bababbbbba -> ababbbbbba
bababbbba -> ababbbbba
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbbbbbbba

# < a,b | babbaaaababbba=a >
babbaaaababbba -> a
babbaaaababba -> abbaaaababbba
babbaaaababa -> abbaaaababba
babbaaaaa -> abbaaaababbbaaaababbba
babbaaaabaa -> abbaaaababa

# < a,b | babbaaababbaba=a >
babbaaababbaba -> a
babbaaababbaa -> abbaaababbaba
babbaaaa -> abbaaababbabaababbaba

# < a,b | babbaaababbbba=a >
babbaaababbbba -> a
babbaaababbba -> abbaaababbbba
babbaaababba -> abbaaababbba
babbaaababa -> abbaaababba
babbaaaa -> abbaaababbbaaababbbba
babbaaabaa -> abbaaababa

# < a,b | babbaaabbabbaa=a >
babbaaabbabbaa -> a
babbaaaba -> aabbabbaa
babbaaaa -> aabbabbaabbaaabbabbaa

# < a,b | babbaaabbabbba=a >
babbaaabbabbba -> a
babbaaabbabba -> abbaaabbabbba
babbaaabbaba -> abbaaabbabba
babbaaaba -> abbaaabbabbbaaabbabbba
babbaaabbaa -> abbaaabbaba
babbaaaa -> abbaaabbabbbaaabbabba

# < a,b | babbaabababbba=a >
babbaabababbba -> a
babbaabababba -> abbaabababbba
babbaabababa -> abbaabababba
babbaabaa -> abbaabababbbaabababbba
babbaababaa -> abbaabababa

# < a,b | babbaababbabba=a >
babbaababbabba -> a
babbaababbaba -> abbaababbabba
babbaababa -> aababbabba
babbaababbaa -> abbaababbaba
babbaabaa -> aababbaba
babbaaa -> abbaababbabababbabba

# < a,b | babbaababbbbba=a >
babbaababbbbba -> a
babbaababbbba -> abbaababbbbba
babbaababbba -> abbaababbbba
babbaababba -> abbaababbba
babbaababa -> abbaababba
babbaaa -> abbaababbbaababbbbba
babbaabaa -> abbaababa

# < a,b | babbaabbabbaba=a >
babbaabbabbaba -> a
babbaabbabbaa -> abbaabbabbaba
babbaaba -> abbaabbabbababbabbaba
babbaaa -> abbaabbabbababbabbaa

# < a,b | babbaabbabbbba=a >
babbaabbabbbba -> a
babbaabbabbba -> abbaabbabbbba
babbaabbabba -> abbaabbabbba
babbaabbaba -> abbaabbabba
babbaaba -> abbaabbabbbaabbabbbba
babbaabbaa -> abbaabbaba
babbaaa -> abbaabbabbbaabbabbba

# < a,b | babbaabbbabbba=a >
babbaabbbabbba -> a
babbaabbbabba -> abbaabbbabbba
babbaabbbaba -> abbaabbbabba
babbaabba -> abbaabbbabbbaabbbabbba
babbaabbbaa -> abbaabbbaba
babbaaba -> abbaabbbabbbaabbbabba
babbaaa -> abbaabbbabbbaabbbaba

# < a,b | babbaabbbbabba=a >
babbaabbbbabba -> a
babbaabbbbaba -> abbaabbbbabba
babbaabbba -> aabbbbabba
babbaabbbbaa -> abbaabbbbaba
babbaabba -> aabbbbaba
babbaaba -> aabbbbaa
babbaaa -> aabbbbaabbaabbbbabba

# < a,b | babbabaababbba=a >
babbabaababbba -> a
babbabaababba -> abbabaababbba
babbabaababa -> abbabaababba
babbabaaa -> abbabaababbbabaababbba
babbabaabaa -> abbabaababa

# < a,b | babbabababbbba=a >
babbabababbbba -> a
babbabababbba -> abbabababbbba
babbabababba -> abbabababbba
babbabababa -> abbabababba
babbabaa -> abbabababbbabababbbba
babbababaa -> abbabababa

# < a,b | babbababbabbba=a >
babbababbabbba -> a
babbababbabba -> abbababbabbba
babbababbaba -> abbababbabba
babbababa -> abbababbabbbababbabbba
babbaa -> abbababbabbabbabbba
babbabaa -> abbababbabbbababbabba

# < a,b | babbababbbbbba=a >
babbababbbbbba -> a
babbababbbbba -> abbababbbbbba
babbababbbba -> abbababbbbba
babbababbba -> abbababbbba
babbababba -> abbababbba
babbababa -> abbababba
babbaa -> abbababbbababbbbbba
babbabaa -> abbababa

# < a,b | babbabbababbba=a >
babbabbababbba -> a
babbabbababba -> abbabbababbba
babbabbababa -> abbabbababba
babbabbaa -> abbabbababbbabbababbba
babbabbabaa -> abbabbababa

# < a,b | babbabbabbbbba=a >
babbabbabbbbba -> a
babbabbabbbba -> abbabbabbbbba
babbabbabbba -> abbabbabbbba
babbabbabba -> abbabbabbba
baba -> abbabbabbbabbbbba
baa -> abbabbabbbabbbba

# < a,b | babbabbbabbbba=a >
babbabbbabbbba -> a
babbabbbabbba -> abbabbbabbbba
babbabbbabba -> abbabbbabbba
babbabba -> abbabbbabbbabbbabbbba
baba -> abbabbbabbbabbbabbbbabbbabbbba
baa -> abbabbbabbbabbbabbbbabbbabbba

# < a,b | babbabbbbabbba=a >
babbabbbbabbba -> a
babbabbbbabba -> abbabbbbabbba
babbabbba -> abbabbbbabbbabbbbabbba
babbabba -> abbabbbbabbbabbbbabba
baba -> abbabbbbabbbabbba
baa -> abbabbbbabbbabba

# < a,b | babbabbbbbbbba=a >
babbabbbbbbbba -> a
babbabbbbbbba -> abbabbbbbbbba
babbabbbbbba -> abbabbbbbbba
babbabbbbba -> abbabbbbbba
babbabbbba -> abbabbbbba
babbabbba -> abbabbbba
babbabba -> abbabbba
baba -> abbabbbabbbbbbbba
baa -> abbabbbabbbbbbba

# < a,b | babbbaababbbba=a >
babbbaababbbba -> a
babbbaababbba -> abbbaababbbba
babbbaababba -> abbbaababbba
babbbaaa -> abbbaababbbbaababbbba
babbbaababa -> abbbaababba
babbbaabaa -> abbbaababa

# < a,b | babbbababbbbba=a >
babbbababbbbba -> a
babbbababbbba -> abbbababbbbba
babbbababbba -> abbbababbbba
babbbababba -> abbbababbba
babbbaa -> abbbababbbbababbbbba
babbbababa -> abbbababba
babbbabaa -> abbbababa

# < a,b | babbbabbabbbba=a >
babbbabbabbbba -> a
babbbabbabbba -> abbbabbabbbba
babbbabbabba -> abbbabbabbba
babbbaba -> abbbabbabbbbabbabbbba
babbbabbaba -> abbbabbabba
babbbaa -> abbbabbabbbbabbabbba
babbbabbaa -> abbbabbaba

# < a,b | babbbabbbbbbba=a >
babbbabbbbbbba -> a
babbbabbbbbba -> abbbabbbbbbba
babbbabbbbba -> abbbabbbbbba
babbbabbbba -> abbbabbbbba
babbbabbba -> abbbabbbba
babba -> abbbabbbbabbbbbbba
baba -> abbbabbbbabbbbbba
baa -> abbbabbbbabbbbba

# < a,b | babbbbabbbbbba=a >
babbbbabbbbbba -> a
babbbbabbbbba -> abbbbabbbbbba
babbbbabbbba -> abbbbabbbbba
babbba -> abbbbabbbbbabbbbbba
babba -> abbbbabbbbbabbbbba
baba -> abbbbabbbbbabbbba
baa -> ababbbbbabbbbbba

# < a,b | bbaaaaaabbabba=a >
bbaaaaaabbabba -> a
bbaaaaaabbaa -> aaaaaabbabba
bbaaaaaaa -> aaaaaabbabbaaaaabbabba

# < a,b | bbaaaaabbaabba=a >
bbaaaaabbaabba -> a
bbaaaaabbaaa -> aaaaabbaabba
bbaaaaaa -> aaaaabbaabbaaabbaabba

# < a,b | bbaaaaabbbabba=a >
bbaaaaabbbabba -> a
bbaaaaabbbaa -> aaaaabbbabba
bbaaaaaba -> aaaaabbbabbaaaabbbabba

# < a,b | bbaaaaabbbbbaa=a >
bbaaaaabbbbbaa -> a
bbaaaaabbba -> aaaabbbbbaa
bbaaaaaba -> aaaabbbbbaaaaaabbbbbaa

# < a,b | bbaaaababbabba=a >
bbaaaababbabba -> a
bbaaaababbaa -> aaaababbabba
bbaaaabaa -> aaaababbabbaaababbabba

# < a,b | bbaaaababbbbaa=a >
bbaaaababbbbaa -> a
bbaaaababba -> aaababbbbaa
bbaaaabaa -> aaababbbbaaaaababbbbaa

# < a,b | bbaaaabbaaabba=a >
bbaaaabbaaabba -> a
bbaaaabbaaaa -> aaaabbaaabba
bbaaaaa -> aaaabbaaabbabbaaabba

# < a,b | bbaaaabbaabbaa=a >
bbaaaabbaabbaa -> a
bbaaaabbaaa -> aaabbaabbaa
bbaaaaa -> aaabbaabbaaabbaabbaa

# < a,b | bbaaaabbabbbba=a >
bbaaaabbabbbba -> a
bbaaaabbabba -> aaaabbabbbba
bbaaaabbaa -> aaaabbabba
bbaaaaa -> aaaabbabbaaabbabbbba

# < a,b | bbaaaabbbaabba=a >
bbaaaabbbaabba -> a
bbaaaabbbaaa -> aaaabbbaabba
bbaaaaba -> aaaabbbaabbaabbbaabba

# < a,b | bbaaaabbbbabba=a >
bbaaaabbbbabba -> a
bbaaaabbbbaa -> aaaabbbbabba
bbaaaabba -> aaaabbbbabbaaabbbbabba
bbaaaaa -> aaaabbbbabbaaabbbbaa

# < a,b | bbaaaabbbbbaaa=a >
bbaaaabbbbbaaa -> a
bbaaaabbba -> aabbbbbaaa
bbaaaaba -> aabbbbbaaaaaabbbbbaaa

# < a,b | bbaaabaabbabba=a >
bbaaabaabbabba -> a
bbaaabaabbaa -> aaabaabbabba
bbaaabaaa -> aaabaabbabbaabaabbabba

# < a,b | bbaaabaabbbbaa=a >
bbaaabaabbbbaa -> a
bbaaabaabba -> aabaabbbbaa
bbaaabaaa -> aabaabbbbaaaabaabbbbaa

# < a,b | bbaaababbaabba=a >
bbaaababbaabba -> a
bbaaababbaaa -> aaababbaabba
bbaaabaa -> aaababbaabbababbaabba

# < a,b | bbaaababbbabba=a >
bbaaababbbabba -> a
bbaaababbbaa -> aaababbbabba
bbaaababa -> aaababbbabbaababbbabba

# < a,b | bbaaababbbbaaa=a >
bbaaababbbbaaa -> a
bbaaababba -> ababbbbaaa
bbaaabaa -> ababbbbaaaaababbbbaaa

# < a,b | bbaaababbbbbaa=a >
bbaaababbbbbaa -> a
bbaaababbba -> aababbbbbaa
bbaaababa -> aababbbbbaaaababbbbbaa

# < a,b | bbaaabbaabbbba=a >
bbaaabbaabbbba -> a
bbaaabbaabba -> aaabbaabbbba
bbaaabbaaa -> aaabbaabba
bbaaaa -> aaabbaabbabbaabbbba

# < a,b | bbaaabbabbabba=a >
bbaaabbabbabba -> a
bbaaabbabbaa -> aaabbabbabba
bbaaabbaa -> aaabbabbabbaabbabbabba
bbaaaa -> aaabbabbabbaabbabbabbaabbabbabba

# < a,b | bbaaabbbaabbaa=a >
bbaaabbbaabbaa -> a
bbaaabbbaaa -> aabbbaabbaa
bbaaaba -> aabbbaabbaabbbaabbaa

# < a,b | bbaaabbbabbaaa=a >
bbaaabbbabbaaa -> a
bbaaabbbaa -> abbbabbaaa
bbaaaba -> abbbabbaaaabbbabbaaa

# < a,b | bbaaabbbabbbba=a >
bbaaabbbabbbba -> a
bbaaabbbabba -> aaabbbabbbba
bbaaabbbaa -> aaabbbabba
bbaaaba -> aaabbbabbaabbbabbbba

# < a,b | bbaaabbbbaabba=a >
bbaaabbbbaabba -> a
bbaaabbbbaaa -> aaabbbbaabba
bbaaabba -> aaabbbbaabbabbbbaabba
bbaaaa -> aaabbbbaabbabbbbaaa

# < a,b | bbaaabbbbbabba=a >
bbaaabbbbbabba -> a
bbaaabbbbbaa -> aaabbbbbabba
bbaaabbba -> aaabbbbbabbaabbbbbabba
bbaaaba -> aaabbbbbabbaabbbbbaa

# < a,b | bbaaabbbbbbbaa=a >
bbaaabbbbbbbaa -> a
bbaaabbbbba -> aabbbbbbbaa
bbaaabbba -> aabbbbbbbaaaabbbbbbbaa
bbaaaba -> aabbbbbbbaaaabbbbbbbaaaabbbbbbbaa

# < a,b | bbaabaaabbabba=a >
bbaabaaabbabba -> a
bbaabaaabbaa -> aabaaabbabba
bbaabaaaa -> aabaaabbabbabaaabbabba

# < a,b | bbaabaaabbbbaa=a >
bbaabaaabbbbaa -> a
bbaabaaabba -> abaaabbbbaa
bbaabaaaa -> abaaabbbbaaabaaabbbbaa

# < a,b | bbaabaabbbabba=a >
bbaabaabbbabba -> a
bbaabaabbbaa -> aabaabbbabba
bbaabaaba -> aabaabbbabbabaabbbabba

# < a,b | bbaabaabbbbbaa=a >
bbaabaabbbbbaa -> a
bbaabaabbba -> abaabbbbbaa
bbaabaaba -> abaabbbbbaaabaabbbbbaa

# < a,b | bbaabababbabba=a >
bbaabababbabba -> a
bbaabababbaa -> aabababbabba
bbaababaa -> aabababbabbabababbabba

# < a,b | bbaabababbbbaa=a >
bbaabababbbbaa -> a
bbaabababba -> abababbbbaa
bbaababaa -> abababbbbaaabababbbbaa

# < a,b | bbaababbaabbba=a >
bbaababbaabbba -> a
bbaababbaaba -> aababbaabbba
bbaabaa -> aababbaabbbabbaabbba

# < a,b | bbaababbabbbba=a >
bbaababbabbbba -> a
bbaababbabba -> aababbabbbba
bbaababbaa -> aababbabba
bbaabaa -> aababbabbababbabbbba

# < a,b | bbaababbbbabba=a >
bbaababbbbabba -> a
bbaababbbbaa -> aababbbbabba
bbaababba -> aababbbbabbababbbbabba
bbaabaa -> aababbbbabbababbbbaa

# < a,b | bbaababbbbbbaa=a >
bbaababbbbbbaa -> a
bbaababbbba -> ababbbbbbaa
bbaababba -> ababbbbbbaaababbbbbbaa
bbaabaa -> ababbbbbbaaababbbbbbaaababbbbbbaa

# < a,b | bbaabbaabbabba=a >
bbaabbaabbabba -> a
bbaabbaabbaa -> aabbaabbabba
bbaaa -> aabbaabbabbabbabba

# < a,b | bbaabbabbaabba=a >
bbaabbabbaabba -> a
bbaabbaa -> abbaabba
bbaaa -> abbaabbabbabbaabba

# < a,b | bbaabbabbbabba=a >
bbaabbabbbabba -> a
bbaabbabbbaa -> aabbabbbabba
bbaabbaba -> aabbabbbabbabbabbbabba

# < a,b | bbaabbabbbbbaa=a >
bbaabbabbbbbaa -> a
bbaabbabbba -> abbabbbbbaa
bbaabbaba -> abbabbbbbaaabbabbbbbaa

# < a,b | bbaabbabbbbbba=a >
bbaabbabbbbbba -> a
bbaabbabbbba -> aabbabbbbbba
bbaabbabba -> aabbabbbba
bbaabbaa -> aabbabba
bbaaa -> aabbabbabbabbbbbba

# < a,b | bbaabbbabbabba=a >
bbaabbbabbabba -> a
bbaabbbabbaa -> aabbbabbabba
bbaabbbaa -> aabbbabbabbabbbabbabba
bbaaba -> aabbbabbabbabbbabbabbabbbabbabba

# < a,b | bbaabbbabbbbaa=a >
bbaabbbabbbbaa -> a
bbaabbbabba -> abbbabbbbaa
bbaabbbaa -> abbbabbbbaaabbbabbbbaa
bbaaba -> abbbabbbbaaabbbabba

# < a,b | bbaabbbbabbbba=a >
bbaabbbbabbbba -> a
bbaabbbbabba -> aabbbbabbbba
bbaabbbbaa -> aabbbbabba
bbaabba -> aabbbbabbabbbbabbbba
bbaaa -> aabbbbabbabbbbabba

# < a,b | bbaabbbbbabbaa=a >
bbaabbbbbabbaa -> a
bbaabbbbbaa -> abbbbbabbaa
bbaabbba -> abbbbbaa
bbaaba -> abbbbbaaabbbbbabbaa

# < a,b | bbabaaabbabbba=a >
bbabaaabbabbba -> a
bbabaaabbaba -> abaaabbabbba
bbabaaaa -> abaaabbabbbaaabbabbba

# < a,b | bbabaaabbbbaba=a >
bbabaaabbbbaba -> a
bbabaaabba -> aaabbbbaba
bbabaaaa -> aaabbbbababaaabbbbaba

# < a,b | bbabaabbababba=a >
bbabaabbababba -> a
bbabaabbabaa -> abaabbababba
bbabaaa -> abaabbababbabbababba

# < a,b | bbabaabbbabbba=a >
bbabaabbbabbba -> a
bbabaabbbaba -> abaabbbabbba
bbabaaba -> abaabbbabbbaabbbabbba

# < a,b | bbabaabbbbabaa=a >
bbabaabbbbabaa -> a
bbabaabba -> abbbbabaa
bbabaaa -> abbbbabaabaabbbbabaa

# < a,b | bbabaabbbbbaba=a >
bbabaabbbbbaba -> a
bbabaabbba -> aabbbbbaba
bbabaaba -> aabbbbbababaabbbbbaba

# < a,b | bbabababbabbba=a >
bbabababbabbba -> a
bbabababbaba -> abababbabbba
bbababaa -> abababbabbbababbabbba

# < a,b | bbabababbbbaba=a >
bbabababbbbaba -> a
bbabababba -> ababbbbaba
bbababaa -> ababbbbababababbbbaba

# < a,b | bbababbabbbbba=a >
bbababbabbbbba -> a
bbababbabbba -> ababbabbbbba
bbababbaba -> ababbabbba
bbabaa -> ababbabbbabbabbbbba

# < a,b | bbababbbbabbba=a >
bbababbbbabbba -> a
bbababbbbaba -> ababbbbabbba
bbababba -> ababbbbabbbabbbbabbba
bbabaa -> ababbbbabbbabbbbaba

# < a,b | bbababbbbbbaba=a >
bbababbbbbbaba -> a
bbababbbba -> abbbbbbaba
bbababba -> abbbbbbabababbbbbbaba
bbabaa -> abbbbbbabababbbbbbabababbbbbbaba

# < a,b | bbabbabbabbbba=a >
bbabbabbabbbba -> a
bbabbabbabba -> abbabbabbbba
bbaa -> abbabbabbbbabbbba

# < a,b | bbbaaabbbabbba=a >
bbbaaabbbabbba -> a
bbbaaabbbaa -> aaabbbabbba
bbbaaaa -> aaabbbabbbaabbbabbba

# < a,b | bbbaabbbbabbba=a >
bbbaabbbbabbba -> a
bbbaabbbbaa -> aabbbbabbba
bbbaaba -> aabbbbabbbabbbbabbba

# < a,b | bbbaabbbbbbbaa=a >
bbbaabbbbbbbaa -> a
bbbaabbbba -> abbbbbbbaa
bbbaaba -> abbbbbbbaaabbbbbbbaa

# < a,b | baaaaaaaaaababa=a >
baaaaaaaaaababa -> a
baaaaaaaaaabaa -> aaaaaaaaaababa
baaaaaaaaaaa -> aaaaaaaaaababaaaaaaaaababa

# < a,b | baaaaaaaaabaaba=a >
baaaaaaaaabaaba -> a
baaaaaaaaabaaa -> aaaaaaaaabaaba
baaaaaaaaaa -> aaaaaaaaabaabaaaaaaabaaba

# < a,b | baaaaaaaaababba=a >
baaaaaaaaababba -> a
baaaaaaaaababa -> aaaaaaaaababba
baaaaaaaaabaa -> aaaaaaaaababa
baaaaaaaaaa -> aaaaaaaaababaaaaaaaababba

# < a,b | baaaaaaaaabbaba=a >
baaaaaaaaabbaba -> a
baaaaaaaaabbaa -> aaaaaaaaabbaba
baaaaaaaaaba -> aaaaaaaaabbabaaaaaaaabbaba
baaaaaaaaaa -> aaaaaaaaabbabaaaaaaaabbaa

# < a,b | baaaaaaaabaaaba=a >
baaaaaaaabaaaba -> a
baaaaaaaabaaaa -> aaaaaaaabaaaba
baaaaaaaaa -> aaaaaaaabaaabaaaaabaaaba

# < a,b | baaaaaaaabaabaa=a >
baaaaaaaabaabaa -> a
baaaaaaaabaaa -> aaaaaaabaabaa
baaaaaaaaa -> aaaaaaabaabaaaaaaabaabaa

# < a,b | baaaaaaaabaabba=a >
baaaaaaaabaabba -> a
baaaaaaaabaaba -> aaaaaaaabaabba
baaaaaaaabaaa -> aaaaaaaabaaba
baaaaaaaaa -> aaaaaaaabaabaaaaaabaabba

# < a,b | baaaaaaaabababa=a >
baaaaaaaabababa -> a
baaaaaaaababaa -> aaaaaaaabababa
baaaaaaaabaa -> aaaaaaaabababaaaaaaabababa
baaaaaaaaa -> aaaaaaaabababaaaaaaabababaaaaaaabababa

# < a,b | baaaaaaaababbba=a >
baaaaaaaababbba -> a
baaaaaaaababba -> aaaaaaaababbba
baaaaaaaababa -> aaaaaaaababba
baaaaaaaabaa -> aaaaaaaababa
baaaaaaaaa -> aaaaaaaababaaaaaaababbba

# < a,b | baaaaaaaabbaaba=a >
baaaaaaaabbaaba -> a
baaaaaaaabbaaa -> aaaaaaaabbaaba
baaaaaaaaba -> aaaaaaaabbaabaaaaaabbaaba
baaaaaaaaa -> aaaaaaaabbaabaaaaaabbaaa

# < a,b | baaaaaaaabbabba=a >
baaaaaaaabbabba -> a
baaaaaaaabbaba -> aaaaaaaabbabba
baaaaaaaabbaa -> aaaaaaaabbaba
baaaaaaaaba -> aaaaaaaabbabaaaaaaabbabba
baaaaaaaaa -> aaaaaaaabbabaaaaaaabbaba

# < a,b | baaaaaaabaaaaba=a >
baaaaaaabaaaaba -> a
baaaaaaabaaaaa -> aaaaaaabaaaaba
baaaaaaaa -> aaaaaaabaaaabaaabaaaaba

# < a,b | baaaaaaabaaabaa=a >
baaaaaaabaaabaa -> a
baaaaaaabaaaa -> aaaaaabaaabaa
baaaaaaaa -> aaaaaabaaabaaaaabaaabaa

# < a,b | baaaaaaabaaabba=a >
baaaaaaabaaabba -> a
baaaaaaabaaaba -> aaaaaaabaaabba
baaaaaaabaaaa -> aaaaaaabaaaba
baaaaaaaa -> aaaaaaabaaabaaaabaaabba

# < a,b | baaaaaaabaababa=a >
baaaaaaabaababa -> a
baaaaaaabaabaa -> aaaaaaabaababa
baaaaaaabaaa -> aaaaaaabaababaaaaaabaababa
baaaaaaaa -> aaaaaaabaababaaaaaabaababaaaaabaababa

# < a,b | baaaaaaabaabbba=a >
baaaaaaabaabbba -> a
baaaaaaabaabba -> aaaaaaabaabbba
baaaaaaabaaba -> aaaaaaabaabba
baaaaaaabaaa -> aaaaaaabaaba
baaaaaaaa -> aaaaaaabaabaaaaabaabbba

# < a,b | baaaaaaababaaba=a >
baaaaaaababaaba -> a
baaaaaaababaaa -> aaaaaaababaaba
baaaaaaabaa -> aaaaaaababaabaaaaababaaba
baaaaaaaa -> aaaaaaababaabaaaaababaabaaaaaababaaba

# < a,b | baaaaaaabababba=a >
baaaaaaabababba -> a
baaaaaaabababa -> aaaaaaabababba
baaaaaaababaa -> aaaaaaabababa
baaaaaaabaa -> aaaaaaabababaaaaaabababba
baaaaaaaa -> aaaaaaabababaaaaaabababbaaaaaabababba

# < a,b | baaaaaaababbaba=a >
baaaaaaababbaba -> a
baaaaaaababbaa -> aaaaaaababbaba
baaaaaaababa -> aaaaaaababbabaaaaaababbaba
baaaaaaabaa -> aaaaaaababbabaaaaaababbaa
baaaaaaaa -> aaaaaaababbabaaaaaababa

# < a,b | baaaaaaababbbba=a >
baaaaaaababbbba -> a
baaaaaaababbba -> aaaaaaababbbba
baaaaaaababba -> aaaaaaababbba
baaaaaaababa -> aaaaaaababba
baaaaaaabaa -> aaaaaaababa
baaaaaaaa -> aaaaaaababaaaaaababbbba

# < a,b | baaaaaaabbaaaba=a >
baaaaaaabbaaaba -> a
baaaaaaabbaaaa -> aaaaaaabbaaaba
baaaaaaaba -> aaaaaaabbaaabaaaabbaaaba
baaaaaaaa -> aaaaaaabbaaabaaaabbaaaa

# < a,b | baaaaaaabbaabba=a >
baaaaaaabbaabba -> a
baaaaaaabbaaba -> aaaaaaabbaabba
baaaaaaabbaaa -> aaaaaaabbaaba
baaaaaaaba -> aaaaaaabbaabaaaaabbaabba
baaaaaaaa -> aaaaaaabbaabaaaaabbaaba

# < a,b | baaaaaaabbababa=a >
baaaaaaabbababa -> a
baaaaaaabbabaa -> aaaaaaabbababa
baaaaaaabbaa -> aaaaaaabbababaaaaaabbababa
baaaaaaaba -> aaaaaaabbababaaaaaabbababaaaaaabbababa
baaaaaaaa -> aaaaaaabbababaaaaaabbababaaaaaabbabaa

# < a,b | baaaaaaabbabbba=a >
baaaaaaabbabbba -> a
baaaaaaabbabba -> aaaaaaabbabbba
baaaaaaabbaba -> aaaaaaabbabba
baaaaaaabbaa -> aaaaaaabbaba
baaaaaaaba -> aaaaaaabbabaaaaaabbabbba
baaaaaaaa -> aaaaaaabbabaaaaaabbabba

# < a,b | baaaaaaabbbabba=a >
baaaaaaabbbabba -> a
baaaaaaabbbaba -> aaaaaaabbbabba
baaaaaaabbbaa -> aaaaaaabbbaba
baaaaaaabba -> aaaaaaabbbabaaaaaabbbabba
baaaaaaaba -> aaaaaaabbbabaaaaaabbbaba
baaaaaaaa -> aaaaaaabbbabaaaaaabbbaa

# < a,b | baaaaaabaaaaaba=a >
baaaaaabaaaaaba -> a
baaaaaabaaaaaa -> aaaaaabaaaaaba
baaaaaaa -> aaaaaabaaaaababaaaaaba

# < a,b | baaaaaabaaaabaa=a >
baaaaaabaaaabaa -> a
baaaaaabaaaaa -> aaaaabaaaabaa
baaaaaaa -> aaaaabaaaabaaabaaaabaa

# < a,b | baaaaaabaaaabba=a >
baaaaaabaaaabba -> a
baaaaaabaaaaba -> aaaaaabaaaabba
baaaaaabaaaaa -> aaaaaabaaaaba
baaaaaaa -> aaaaaabaaaabaabaaaabba

# < a,b | baaaaaabaaabaaa=a >
baaaaaabaaabaaa -> a
baaaaaabaaaa -> aaaabaaabaaa
baaaaaaa -> aaaabaaabaaaaabaaabaaa

# < a,b | baaaaaabaaababa=a >
baaaaaabaaababa -> a
baaaaaabaaabaa -> aaaaaabaaababa
baaaaaabaaaa -> aaaaaabaaababaaaaabaaababa
baaaaaaa -> aaaaaabaaababaaaaabaaababaaabaaababa

# < a,b | baaaaaabaaabbba=a >
baaaaaabaaabbba -> a
baaaaaabaaabba -> aaaaaabaaabbba
baaaaaabaaaba -> aaaaaabaaabba
baaaaaabaaaa -> aaaaaabaaaba
baaaaaaa -> aaaaaabaaabaaabaaabbba

# < a,b | baaaaaabaabaaba=a >
baaaaaabaabaaba -> a
baaaaaabaabaaa -> aaaaaabaabaaba
baaaaaabaaa -> aaaaaabaabaabaaaabaabaaba
baaaaaaa -> aaaaaabaabaabaaaabaabaabaaaabaabaaba

# < a,b | baaaaaabaababaa=a >
baaaaaabaababaa -> a
baaaaaabaabaa -> aaaaabaababaa
baaaaaabaaa -> aaaaabaabaa
baaaaaaa -> aaaaabaabaaaaabaababaa

# < a,b | baaaaaabaababba=a >
baaaaaabaababba -> a
baaaaaabaababa -> aaaaaabaababba
baaaaaabaabaa -> aaaaaabaababa
baaaaaabaaa -> aaaaaabaababaaaaabaababba
baaaaaaa -> aaaaaabaababaaaaabaababbaaaabaababba

# < a,b | baaaaaabaabbaba=a >
baaaaaabaabbaba -> a
baaaaaabaabbaa -> aaaaaabaabbaba
baaaaaabaaba -> aaaaaabaabbabaaaaabaabbaba
baaaaaabaaa -> aaaaaabaabbabaaaaabaabbaa
baaaaaaa -> aaaaaabaabbabaaaaabaabbaaaaabaabbaba

# < a,b | baaaaaabaabbbba=a >
baaaaaabaabbbba -> a
baaaaaabaabbba -> aaaaaabaabbbba
baaaaaabaabba -> aaaaaabaabbba
baaaaaabaaba -> aaaaaabaabba
baaaaaabaaa -> aaaaaabaaba
baaaaaaa -> aaaaaabaabaaaabaabbbba

# < a,b | baaaaaababaaaba=a >
baaaaaababaaaba -> a
baaaaaababaaaa -> aaaaaababaaaba
baaaaaabaa -> aaaaaababaaabaaababaaaba
baaaaaaa -> aaaaaababaaabaaababaaabaaaaababaaaba

# < a,b | baaaaaababaabaa=a >
baaaaaababaabaa -> a
baaaaaababaaa -> aaaaababaabaa
baaaaaabaa -> aaaaababaabaaaaababaabaa
baaaaaaa -> aaaaababaabaaaaababaaa

# < a,b | baaaaaababaabba=a >
baaaaaababaabba -> a
baaaaaababaaba -> aaaaaababaabba
baaaaaababaaa -> aaaaaababaaba
baaaaaabaa -> aaaaaababaabaaaababaabba
baaaaaaa -> aaaaaababaabaaaababaabbaaaaababaabba

# < a,b | baaaaaababababa=a >
baaaaaababababa -> a
baaaaaabababaa -> aaaaaababababa
baaaaaababaa -> aaaaaababababaaaaababababa
baaaaaabaa -> aaaaaababababaaaaababababaaaaababababa
baaaaaaa -> aaaaaababababaaaaababababaaaaababababaaaaababababa

# < a,b | baaaaaabababbba=a >
baaaaaabababbba -> a
baaaaaabababba -> aaaaaabababbba
baaaaaabababa -> aaaaaabababba
baaaaaababaa -> aaaaaabababa
baaaaaabaa -> aaaaaabababaaaaabababbba
baaaaaaa -> aaaaaabababaaaaabababbbaaaaabababbba

# < a,b | baaaaaababbabba=a >
baaaaaababbabba -> a
baaaaaababbaba -> aaaaaababbabba
baaaaaababbaa -> aaaaaababbaba
baaaaaababa -> aaaaaababbabaaaaababbabba
baaaaaabaa -> aaaaaababbabaaaaababbaba
baaaaaaa -> aaaaaababbabaaaaababbabaaaaababbabba

# < a,b | baaaaaababbbbba=a >
baaaaaababbbbba -> a
baaaaaababbbba -> aaaaaababbbbba
baaaaaababbba -> aaaaaababbbba
baaaaaababba -> aaaaaababbba
baaaaaababa -> aaaaaababba
baaaaaabaa -> aaaaaababa
baaaaaaa -> aaaaaababaaaaababbbbba

# < a,b | baaaaaabbaaaaba=a >
baaaaaabbaaaaba -> a
baaaaaabbaaaaa -> aaaaaabbaaaaba
baaaaaaba -> aaaaaabbaaaabaabbaaaaba
baaaaaaa -> aaaaaabbaaaabaabbaaaaa

# < a,b | baaaaaabbaaabba=a >
baaaaaabbaaabba -> a
baaaaaabbaaaba -> aaaaaabbaaabba
baaaaaabbaaaa -> aaaaaabbaaaba
baaaaaaba -> aaaaaabbaaabaaabbaaabba
baaaaaaa -> aaaaaabbaaabaaabbaaaba

# < a,b | baaaaaabbaababa=a >
baaaaaabbaababa -> a
baaaaaabbaabaa -> aaaaaabbaababa
baaaaaabbaaa -> aaaaaabbaababaaaaabbaababa
baaaaaaba -> aaaaaabbaababaaaaabbaababaaaabbaababa
baaaaaaa -> aaaaaabbaababaaaaabbaababaaaabbaabaa

# < a,b | baaaaaabbaabbba=a >
baaaaaabbaabbba -> a
baaaaaabbaabba -> aaaaaabbaabbba
baaaaaabbaaba -> aaaaaabbaabba
baaaaaabbaaa -> aaaaaabbaaba
baaaaaaba -> aaaaaabbaabaaaabbaabbba
baaaaaaa -> aaaaaabbaabaaaabbaabba

# < a,b | baaaaaabbabaaba=a >
baaaaaabbabaaba -> a
baaaaaabbabaaa -> aaaaaabbabaaba
baaaaaabbaa -> aaaaaabbabaabaaaabbabaaba
baaaaaaba -> aaaaaabbabaabaaaabbabaabaaaaabbabaaba
baaaaaaa -> aaaaaabbabaabaaaabbabaabaaaaabbabaaa

# < a,b | baaaaaabbababba=a >
baaaaaabbababba -> a
baaaaaabbababa -> aaaaaabbababba
baaaaaabbabaa -> aaaaaabbababa
baaaaaabbaa -> aaaaaabbababaaaaabbababba
baaaaaaba -> aaaaaabbababaaaaabbababbaaaaabbababba
baaaaaaa -> aaaaaabbababaaaaabbababbaaaaabbababa

# < a,b | baaaaaabbabbaba=a >
baaaaaabbabbaba -> a
baaaaaabbabbaa -> aaaaaabbabbaba
baaaaaabbaba -> aaaaaabbabbabaaaaabbabbaba
baaaaaabbaa -> aaaaaabbabbabaaaaabbabbaa
baaaaaaba -> aaaaaabbabbabaaaaabbaba
baaaaaaa -> aaaaaabbabbabaaaaabbaa

# < a,b | baaaaaabbabbbba=a >
baaaaaabbabbbba -> a
baaaaaabbabbba -> aaaaaabbabbbba
baaaaaabbabba -> aaaaaabbabbba
baaaaaabbaba -> aaaaaabbabba
baaaaaabbaa -> aaaaaabbaba
baaaaaaba -> aaaaaabbabaaaaabbabbbba
baaaaaaa -> aaaaaabbabaaaaabbabbba

# < a,b | baaaaaabbbaabba=a >
baaaaaabbbaabba -> a
baaaaaabbbaaba -> aaaaaabbbaabba
baaaaaabbbaaa -> aaaaaabbbaaba
baaaaaabba -> aaaaaabbbaabaaaabbbaabba
baaaaaaba -> aaaaaabbbaabaaaabbbaaba
baaaaaaa -> aaaaaabbbaabaaaabbbaaa

# < a,b | baaaaaabbbabbba=a >
baaaaaabbbabbba -> a
baaaaaabbbabba -> aaaaaabbbabbba
baaaaaabbbaba -> aaaaaabbbabba
baaaaaabbbaa -> aaaaaabbbaba
baaaaaabba -> aaaaaabbbabaaaaabbbabbba
baaaaaaba -> aaaaaabbbabaaaaabbbabba
baaaaaaa -> aaaaaabbbabaaaaabbbaba

# < a,b | baaaaabaaaaabba=a >
baaaaabaaaaabba -> a
baaaaabaaaaaba -> aaaaabaaaaabba
baaaaaa -> aaaaabaaaaabbaaaaabba

# < a,b | baaaaabaaaabaaa=a >
baaaaabaaaabaaa -> a
baaaaabaaaaa -> aaabaaaabaaa
baaaaaa -> aaabaaaabaaabaaaabaaa

# < a,b | baaaaabaaaababa=a >
baaaaabaaaababa -> a
baaaaabaaaabaa -> aaaaabaaaababa
baaaaabaaaaa -> aaaaabaaaababaaaabaaaababa
baaaaaa -> aaaaabaaaababaaaabaaaabababaaaababa

# < a,b | baaaaabaaaabbba=a >
baaaaabaaaabbba -> a
baaaaabaaaabba -> aaaaabaaaabbba
baaaaabaaaaba -> aaaaabaaaabba
baaaaabaaaaa -> aaaaabaaaaba
baaaaaa -> aaaaabaaaababaaaabbba

# < a,b | baaaaabaaabaaba=a >
baaaaabaaabaaba -> a
baaaaabaaabaaa -> aaaaabaaabaaba
baaaaabaaaa -> aaaaabaaabaabaaabaaabaaba
baaaaaa -> aaaaabaaabaabaaabaaabaabaabaaabaaba

# < a,b | baaaaabaaababaa=a >
baaaaabaaababaa -> a
baaaaabaaabaa -> aaaabaaababaa
baaaaabaaaa -> aaaabaaabaa
baaaaaa -> aaaabaaabaaabaaababaa

# < a,b | baaaaabaaababba=a >
baaaaabaaababba -> a
baaaaabaaababa -> aaaaabaaababba
baaaaabaaabaa -> aaaaabaaababa
baaaaabaaaa -> aaaaabaaababaaaabaaababba
baaaaaa -> aaaaabaaababaaaabaaababbaabaaababba

# < a,b | baaaaabaaabbaba=a >
baaaaabaaabbaba -> a
baaaaabaaabbaa -> aaaaabaaabbaba
baaaaabaaaba -> aaaaabaaabbabaaaabaaabbaba
baaaaabaaaa -> aaaaabaaabbabaaaabaaabbaa
baaaaaa -> aaaaabaaabbabaaaabaaabbaaabaaabbaba

# < a,b | baaaaabaaabbbba=a >
baaaaabaaabbbba -> a
baaaaabaaabbba -> aaaaabaaabbbba
baaaaabaaabba -> aaaaabaaabbba
baaaaabaaaba -> aaaaabaaabba
baaaaabaaaa -> aaaaabaaaba
baaaaaa -> aaaaabaaabaabaaabbbba

# < a,b | baaaaabaabaaaba=a >
baaaaabaabaaaba -> a
baaaaabaabaaaa -> aaaaabaabaaaba
baaaaabaaa -> aaaaabaabaaabaabaabaaaba
baaaaaa -> aaaaabaabaaabaabaabaaabaaabaabaaaba

# < a,b | baaaaabaabaabaa=a >
baaaaabaabaabaa -> a
baaaaabaabaaa -> aaaabaabaabaa
baaaaabaaa -> aaaabaabaabaaaabaabaabaa
baaaaaa -> aaaabaabaabaaaabaabaabaaaabaabaabaa

# < a,b | baaaaabaabaabba=a >
baaaaabaabaabba -> a
baaaaabaabaaba -> aaaaabaabaabba
baaaaabaabaaa -> aaaaabaabaaba
baaaaabaaa -> aaaaabaabaabaaabaabaabba
baaaaaa -> aaaaabaabaabaaabaabaabbaaabaabaabba

# < a,b | baaaaabaabababa=a >
baaaaabaabababa -> a
baaaaabaababaa -> aaaaabaabababa
baaaaabaabaa -> aaaaabaabababaaaabaabababa
baaaaabaaa -> aaaaabaabababaaaabaabababaaaabaabababa
baaaaaa -> aaaaabaabababaaaabaabababaaaabaabababaaabaabababa

# < a,b | baaaaabaababbba=a >
baaaaabaababbba -> a
baaaaabaababba -> aaaaabaababbba
baaaaabaababa -> aaaaabaababba
baaaaabaabaa -> aaaaabaababa
baaaaabaaa -> aaaaabaababaaaabaababbba
baaaaaa -> aaaaabaababaaaabaababbbaaabaababbba

# < a,b | baaaaabaabbaaba=a >
baaaaabaabbaaba -> a
baaaaabaabbaaa -> aaaaabaabbaaba
baaaaabaaba -> aaaaabaabbaabaaabaabbaaba
baaaaabaaa -> aaaaabaabbaabaaabaabbaaa
baaaaaa -> aaaaabaabbaabaaabaaba

# < a,b | baaaaabaabbabba=a >
baaaaabaabbabba -> a
baaaaabaabbaba -> aaaaabaabbabba
baaaaabaabbaa -> aaaaabaabbaba
baaaaabaaba -> aaaaabaabbabaaaabaabbabba
baaaaabaaa -> aaaaabaabbabaaaabaabbaba
baaaaaa -> aaaaabaabbabaaaabaabbabaaabaabbabba

# < a,b | baaaaabaabbbbba=a >
baaaaabaabbbbba -> a
baaaaabaabbbba -> aaaaabaabbbbba
baaaaabaabbba -> aaaaabaabbbba
baaaaabaabba -> aaaaabaabbba
baaaaabaaba -> aaaaabaabba
baaaaabaaa -> aaaaabaaba
baaaaaa -> aaaaabaabaaabaabbbbba

# < a,b | baaaaababaaaaba=a >
baaaaababaaaaba -> a
baaaaababaaaaa -> aaaaababaaaaba
baaaaabaa -> aaaaababaaaabababaaaaba
baaaaaa -> aaaaababaaaabababaaaabaaaababaaaaba

# < a,b | baaaaababaaabaa=a >
baaaaababaaabaa -> a
baaaaababaaaa -> aaaababaaabaa
baaaaabaa -> aaaababaaabaaababaaabaa
baaaaaa -> aaaababaaabaaababaaaa

# < a,b | baaaaababaaabba=a >
baaaaababaaabba -> a
baaaaababaaaba -> aaaaababaaabba
baaaaababaaaa -> aaaaababaaaba
baaaaabaa -> aaaaababaaabaababaaabba
baaaaaa -> aaaaababaaabaababaaabbaaaababaaabba

# < a,b | baaaaababaababa=a >
baaaaababaababa -> a
baaaaababaabaa -> aaaaababaababa
baaaaababaaa -> aaaaababaababaaaababaababa
baaaaabaa -> aaaaababaababaaaababaababaaababaababa
baaaaaa -> aaaaababaababaaaababaababaaababaababaaaababaababa

# < a,b | baaaaababaabbba=a >
baaaaababaabbba -> a
baaaaababaabba -> aaaaababaabbba
baaaaababaaba -> aaaaababaabba
baaaaababaaa -> aaaaababaaba
baaaaabaa -> aaaaababaabaaababaabbba
baaaaaa -> aaaaababaabaaababaabbbaaaababaabbba

# < a,b | baaaaabababaaba=a >
baaaaabababaaba -> a
baaaaabababaaa -> aaaaabababaaba
baaaaababaa -> aaaaabababaabaaabababaaba
baaaaabaa -> aaaaabababaabaaabababaabaaaabababaaba
baaaaaa -> aaaaabababaabaaabababaabaaaabababaabaaaabababaaba

# < a,b | baaaaababababba=a >
baaaaababababba -> a
baaaaababababa -> aaaaababababba
baaaaabababaa -> aaaaababababa
baaaaababaa -> aaaaababababaaaababababba
baaaaabaa -> aaaaababababaaaababababbaaaababababba
baaaaaa -> aaaaababababaaaababababbaaaababababbaaaababababba

# < a,b | baaaaabababbaba=a >
baaaaabababbaba -> a
baaaaabababbaa -> aaaaabababbaba
baaaaabababa -> aaaaabababbabaaaabababbaba
baaaaababaa -> aaaaabababbabaaaabababbaa
baaaaabaa -> aaaaabababbabaaaabababa
baaaaaa -> aaaaabababbabaaaabababaaaabababbaba

# < a,b | baaaaabababbbba=a >
baaaaabababbbba -> a
baaaaabababbba -> aaaaabababbbba
baaaaabababba -> aaaaabababbba
baaaaabababa -> aaaaabababba
baaaaababaa -> aaaaabababa
baaaaabaa -> aaaaabababaaaabababbbba
baaaaaa -> aaaaabababaaaabababbbbaaaabababbbba

# < a,b | baaaaababbaabba=a >
baaaaababbaabba -> a
baaaaababbaaba -> aaaaababbaabba
baaaaababbaaa -> aaaaababbaaba
baaaaababa -> aaaaababbaabaaababbaabba
baaaaabaa -> aaaaababbaabaaababbaaba
baaaaaa -> aaaaababbaabaaababbaabaaaababbaabba

# < a,b | baaaaababbababa=a >
baaaaababbababa -> a
baaaaababbabaa -> aaaaababbababa
baaaaababbaa -> aaaaababbababaaaababbababa
baaaaababa -> aaaaababbababaaaababbababaaaababbababa
baaaaabaa -> aaaaababbababaaaababbababaaaababbabaa
baaaaaa -> aaaaababbababaaaababbababaaaababbaa

# < a,b | baaaaababbabbba=a >
baaaaababbabbba -> a
baaaaababbabba -> aaaaababbabbba
baaaaababbaba -> aaaaababbabba
baaaaababbaa -> aaaaababbaba
baaaaababa -> aaaaababbabaaaababbabbba
baaaaabaa -> aaaaababbabaaaababbabba
baaaaaa -> aaaaababbabaaaababbabbaaaababbabbba

# < a,b | baaaaababbbabba=a >
baaaaababbbabba -> a
baaaaababbbaba -> aaaaababbbabba
baaaaababbbaa -> aaaaababbbaba
baaaaababba -> aaaaababbbabaaaababbbabba
baaaaababa -> aaaaababbbabaaaababbbaba
baaaaabaa -> aaaaababbbabaaaababbbaa
baaaaaa -> aaaaababbbabaaaababba

# < a,b | baaaaababbbbbba=a >
baaaaababbbbbba -> a
baaaaababbbbba -> aaaaababbbbbba
baaaaababbbba -> aaaaababbbbba
baaaaababbba -> aaaaababbbba
baaaaababba -> aaaaababbba
baaaaababa -> aaaaababba
baaaaabaa -> aaaaababa
baaaaaa -> aaaaababaaaababbbbbba

# < a,b | baaaaabbaaaabba=a >
baaaaabbaaaabba -> a
baaaaabbaaaaba -> aaaaabbaaaabba
baaaaabbaaaaa -> aaaaabbaaaaba
baaaaaba -> aaaaabbaaaababbaaaabba
baaaaaa -> aaaaabbaaaababbaaaaba

# < a,b | baaaaabbaaababa=a >
baaaaabbaaababa -> a
baaaaabbaaabaa -> aaaaabbaaababa
baaaaabbaaaa -> aaaaabbaaababaaaabbaaababa
baaaaaba -> aaaaabbaaababaaaabbaaababaabbaaababa
baaaaaa -> aaaaabbaaababaaaabbaaababaabbaaabaa

# < a,b | baaaaabbaaabbba=a >
baaaaabbaaabbba -> a
baaaaabbaaabba -> aaaaabbaaabbba
baaaaabbaaaba -> aaaaabbaaabba
baaaaabbaaaa -> aaaaabbaaaba
baaaaaba -> aaaaabbaaabaabbaaabbba
baaaaaa -> aaaaabbaaabaabbaaabba

# < a,b | baaaaabbaabaaba=a >
baaaaabbaabaaba -> a
baaaaabbaabaaa -> aaaaabbaabaaba
baaaaabbaaa -> aaaaabbaabaabaaabbaabaaba
baaaaaba -> aaaaabbaabaabaaabbaabaabaaabbaabaaba
baaaaaa -> aaaaabbaabaabaaabbaabaabaaabbaabaaa

# < a,b | baaaaabbaababba=a >
baaaaabbaababba -> a
baaaaabbaababa -> aaaaabbaababba
baaaaabbaabaa -> aaaaabbaababa
baaaaabbaaa -> aaaaabbaababaaaabbaababba
baaaaaba -> aaaaabbaababaaaabbaababbaaabbaababba
baaaaaa -> aaaaabbaababaaaabbaababbaaabbaababa

# < a,b | baaaaabbaabbaba=a >
baaaaabbaabbaba -> a
baaaaabbaabbaa -> aaaaabbaabbaba
baaaaabbaaba -> aaaaabbaabbabaaaabbaabbaba
baaaaabbaaa -> aaaaabbaabbabaaaabbaabbaa
baaaaaba -> aaaaabbaabbabaaaabbaabbaaaabbaabbaba
baaaaaa -> aaaaabbaabbabaaaabbaabbaaaabbaabbaa

# < a,b | baaaaabbaabbbba=a >
baaaaabbaabbbba -> a
baaaaabbaabbba -> aaaaabbaabbbba
baaaaabbaabba -> aaaaabbaabbba
baaaaabbaaba -> aaaaabbaabba
baaaaabbaaa -> aaaaabbaaba
baaaaaba -> aaaaabbaabaaabbaabbbba
baaaaaa -> aaaaabbaabaaabbaabbba

# < a,b | baaaaabbabaaaba=a >
baaaaabbabaaaba -> a
baaaaabbabaaaa -> aaaaabbabaaaba
baaaaabbaa -> aaaaabbabaaabaabbabaaaba
baaaaaba -> aaaaabbabaaabaabbabaaabaaaabbabaaaba
baaaaaa -> aaaaabbabaaabaabbabaaabaaaabbabaaaa

# < a,b | baaaaabbabaabba=a >
baaaaabbabaabba -> a
baaaaabbabaaba -> aaaaabbabaabba
baaaaabbabaaa -> aaaaabbabaaba
baaaaabbaa -> aaaaabbabaabaaabbabaabba
baaaaaba -> aaaaabbabaabaaabbabaabbaaaabbabaabba
baaaaaa -> aaaaabbabaabaaabbabaabbaaaabbabaaba

# < a,b | baaaaabbabababa=a >
baaaaabbabababa -> a
baaaaabbababaa -> aaaaabbabababa
baaaaabbabaa -> aaaaabbabababaaaabbabababa
baaaaabbaa -> aaaaabbabababaaaabbabababaaaabbabababa
baaaaaba -> aaaaabbabababaaaabbabababaaaabbabababaaaabbabababa
baaaaaa -> aaaaabbabababaaaabbabababaaaabbabababaaaabbababaa

# < a,b | baaaaabbababbba=a >
baaaaabbababbba -> a
baaaaabbababba -> aaaaabbababbba
baaaaabbababa -> aaaaabbababba
baaaaabbabaa -> aaaaabbababa
baaaaabbaa -> aaaaabbababaaaabbababbba
baaaaaba -> aaaaabbababaaaabbababbbaaaabbababbba
baaaaaa -> aaaaabbababaaaabbababbbaaaabbababba

# < a,b | baaaaabbabbabba=a >
baaaaabbabbabba -> a
baaaaabbabbaba -> aaaaabbabbabba
baaaaabbabbaa -> aaaaabbabbaba
baaaaabbaba -> aaaaabbabbabaaaabbabbabba
baaaaabbaa -> aaaaabbabbabaaaabbabbaba
baaaaaba -> aaaaabbabbabaaaabbabbabaaaabbabbabba
baaaaaa -> aaaaabbabbabaaaabbabbabaaaabbabbaba

# < a,b | baaaaabbabbbbba=a >
baaaaabbabbbbba -> a
baaaaabbabbbba -> aaaaabbabbbbba
baaaaabbabbba -> aaaaabbabbbba
baaaaabbabba -> aaaaabbabbba
baaaaabbaba -> aaaaabbabba
baaaaabbaa -> aaaaabbaba
baaaaaba -> aaaaabbabaaaabbabbbbba
baaaaaa -> aaaaabbabaaaabbabbbba

# < a,b | baaaaabbbaaabba=a >
baaaaabbbaaabba -> a
baaaaabbbaaaba -> aaaaabbbaaabba
baaaaabbbaaaa -> aaaaabbbaaaba
baaaaabba -> aaaaabbbaaabaabbbaaabba
baaaaaba -> aaaaabbbaaabaabbbaaaba
baaaaaa -> aaaaabbbaaabaabbbaaaa

# < a,b | baaaaabbbaabbba=a >
baaaaabbbaabbba -> a
baaaaabbbaabba -> aaaaabbbaabbba
baaaaabbbaaba -> aaaaabbbaabba
baaaaabbbaaa -> aaaaabbbaaba
baaaaabba -> aaaaabbbaabaaabbbaabbba
baaaaaba -> aaaaabbbaabaaabbbaabba
baaaaaa -> aaaaabbbaabaaabbbaaba

# < a,b | baaaaabbbababba=a >
baaaaabbbababba -> a
baaaaabbbababa -> aaaaabbbababba
baaaaabbbabaa -> aaaaabbbababa
baaaaabbbaa -> aaaaabbbababaaaabbbababba
baaaaabba -> aaaaabbbababaaaabbbababbaaaabbbababba
baaaaaba -> aaaaabbbababaaaabbbababbaaaabbbababa
baaaaaa -> aaaaabbbababaaaabbbababbaaaabbbabaa

# < a,b | baaaaabbbabbbba=a >
baaaaabbbabbbba -> a
baaaaabbbabbba -> aaaaabbbabbbba
baaaaabbbabba -> aaaaabbbabbba
baaaaabbbaba -> aaaaabbbabba
baaaaabbbaa -> aaaaabbbaba
baaaaabba -> aaaaabbbabaaaabbbabbbba
baaaaaba -> aaaaabbbabaaaabbbabbba
baaaaaa -> aaaaabbbabaaaabbbabba

# < a,b | baaaaabbbbabbba=a >
baaaaabbbbabbba -> a
baaaaabbbbabba -> aaaaabbbbabbba
baaaaabbbbaba -> aaaaabbbbabba
baaaaabbbbaa -> aaaaabbbbaba
baaaaabbba -> aaaaabbbbabaaaabbbbabbba
baaaaabba -> aaaaabbbbabaaaabbbbabba
baaaaaba -> aaaaabbbbabaaaabbbbaba
baaaaaa -> aaaaabbbbabaaaabbbbaa

# < a,b | baaaabaaaaababa=a >
baaaabaaaaababa -> a
baaaabaaaaabaa -> aaaabaaaaababa
baaaabaaaaaa -> aaaabaaaaababaaabaaaaababa

# < a,b | baaaabaaaaabbaa=a >
baaaabaaaaabbaa -> a
baaaabaaaaaba -> aaabaaaaabbaa
baaaabaaaaaa -> aaabaaaaabbaaaaabaaaaabbaa

# < a,b | baaaabaaaabaaba=a >
baaaabaaaabaaba -> a
baaaabaaaabaaa -> aaaabaaaabaaba
baaaaa -> aaaabaaaabaabaabaaba

# < a,b | baaaabaaaababaa=a >
baaaabaaaababaa -> a
baaaabaaaabaa -> aaabaaaababaa
baaaaa -> aaabaaaababaaaababaa

# < a,b | baaaabaaaababba=a >
baaaabaaaababba -> a
baaaabaaaababa -> aaaabaaaababba
baaaabaaaabaa -> aaaabaaaababa
baaaaa -> aaaabaaaababaaababba

# < a,b | baaaabaaaabbaba=a >
baaaabaaaabbaba -> a
baaaabaaaabbaa -> aaaabaaaabbaba
baaaabaaaaba -> aaaabaaaabbabaaabaaaabbaba
baaaaa -> aaaabaaaabbabaaabaaaabbabaaaabbaba

# < a,b | baaaabaaaabbbba=a >
baaaabaaaabbbba -> a
baaaabaaaabbba -> aaaabaaaabbbba
baaaabaaaabba -> aaaabaaaabbba
baaaabaaaaba -> aaaabaaaabba
baaaaa -> aaaabaaaabbaaaabbbba

# < a,b | baaaabaaabaaaba=a >
baaaabaaabaaaba -> a
baaaabaaabaaaa -> aaaabaaabaaaba
baaaabaaaa -> aaaabaaabaaababaaabaaaba
baaaaa -> aaaabaaabaaababaaabaaababaaabaaaba

# < a,b | baaaabaaabaabaa=a >
baaaabaaabaabaa -> a
baaaabaaabaaa -> aaabaaabaabaa
baaaabaaaa -> aaabaaabaabaaabaaabaabaa
baaaaa -> aaabaaabaabaaabaaabaabaabaaabaabaa

# < a,b | baaaabaaabaabba=a >
baaaabaaabaabba -> a
baaaabaaabaaba -> aaaabaaabaabba
baaaabaaabaaa -> aaaabaaabaaba
baaaabaaaa -> aaaabaaabaabaabaaabaabba
baaaaa -> aaaabaaabaabaabaaabaabbabaaabaabba

# < a,b | baaaabaaabababa=a >
baaaabaaabababa -> a
baaaabaaababaa -> aaaabaaabababa
baaaabaaabaa -> aaaabaaabababaaabaaabababa
baaaabaaaa -> aaaabaaabababaaabaaabababaaabaaabababa
baaaaa -> aaaabaaabababaaabaaabababaaabaaababababaaabababa

# < a,b | baaaabaaababbba=a >
baaaabaaababbba -> a
baaaabaaababba -> aaaabaaababbba
baaaabaaababa -> aaaabaaababba
baaaabaaabaa -> aaaabaaababa
baaaabaaaa -> aaaabaaababaaabaaababbba
baaaaa -> aaaabaaababaaabaaababbbabaaababbba

# < a,b | baaaabaaabbaaba=a >
baaaabaaabbaaba -> a
baaaabaaabbaaa -> aaaabaaabbaaba
baaaabaaaba -> aaaabaaabbaabaabaaabbaaba
baaaabaaaa -> aaaabaaabbaabaabaaabbaaa
baaaaa -> aaaabaaabbaabaabaaabbaaabaaabbaaba

# < a,b | baaaabaaabbabba=a >
baaaabaaabbabba -> a
baaaabaaabbaba -> aaaabaaabbabba
baaaabaaabbaa -> aaaabaaabbaba
baaaabaaaba -> aaaabaaabbabaaabaaabbabba
baaaabaaaa -> aaaabaaabbabaaabaaabbaba
baaaaa -> aaaabaaabbabaaabaaabbababaaabbabba

# < a,b | baaaabaaabbbbba=a >
baaaabaaabbbbba -> a
baaaabaaabbbba -> aaaabaaabbbbba
baaaabaaabbba -> aaaabaaabbbba
baaaabaaabba -> aaaabaaabbba
baaaabaaaba -> aaaabaaabba
baaaabaaaa -> aaaabaaaba
baaaaa -> aaaabaaababaaabbbbba

# < a,b | baaaabaabaaaaba=a >
baaaabaabaaaaba -> a
baaaabaaa -> aabaaaaba
baaaaa -> aabaaaabaabaabaaaaba

# < a,b | baaaabaabaaabaa=a >
baaaabaabaaabaa -> a
baaaabaabaaaa -> aaabaabaaabaa
baaaabaaa -> aaabaabaaabaabaabaaabaa
baaaaa -> aaabaabaaabaabaabaaabaaabaabaaabaa

# < a,b | baaaabaabaaabba=a >
baaaabaabaaabba -> a
baaaabaabaaaba -> aaaabaabaaabba
baaaabaabaaaa -> aaaabaabaaaba
baaaabaaa -> aaaabaabaaababaabaaabba
baaaaa -> aaaabaabaaababaabaaabbaabaabaaabba

# < a,b | baaaabaabaababa=a >
baaaabaabaababa -> a
baaaabaabaabaa -> aaaabaabaababa
baaaabaabaaa -> aaaabaabaababaaabaabaababa
baaaabaaa -> aaaabaabaababaaabaabaababaabaabaababa
baaaaa -> aaaabaabaababaaabaabaababaabaabaababaabaabaababa

# < a,b | baaaabaabaabbba=a >
baaaabaabaabbba -> a
baaaabaabaabba -> aaaabaabaabbba
baaaabaabaaba -> aaaabaabaabba
baaaabaabaaa -> aaaabaabaaba
baaaabaaa -> aaaabaabaabaabaabaabbba
baaaaa -> aaaabaabaabaabaabaabbbaabaabaabbba

# < a,b | baaaabaababaaba=a >
baaaabaababaaba -> a
baaaabaababaaa -> aaaabaababaaba
baaaabaabaa -> aaaabaababaabaabaababaaba
baaaabaaa -> aaaabaababaabaabaababaabaaabaababaaba
baaaaa -> aaaabaababaabaabaababaabaaabaababaabaabaababaaba

# < a,b | baaaabaabababaa=a >
baaaabaabababaa -> a
baaaabaababaa -> aaabaabababaa
baaaabaabaa -> aaabaababaa
baaaabaaa -> aaabaabaa
baaaaa -> aaabaabaaabaabababaa

# < a,b | baaaabaabababba=a >
baaaabaabababba -> a
baaaabaabababa -> aaaabaabababba
baaaabaababaa -> aaaabaabababa
baaaabaabaa -> aaaabaabababaaabaabababba
baaaabaaa -> aaaabaabababaaabaabababbaaabaabababba
baaaaa -> aaaabaabababaaabaabababbaaabaabababbaabaabababba

# < a,b | baaaabaababbaba=a >
baaaabaababbaba -> a
baaaabaababbaa -> aaaabaababbaba
baaaabaababa -> aaaabaababbabaaabaababbaba
baaaabaabaa -> aaaabaababbabaaabaababbaa
baaaabaaa -> aaaabaababbabaaabaababa
baaaaa -> aaaabaababbabaaabaababaabaababbaba

# < a,b | baaaabaababbbba=a >
baaaabaababbbba -> a
baaaabaababbba -> aaaabaababbbba
baaaabaababba -> aaaabaababbba
baaaabaababa -> aaaabaababba
baaaabaabaa -> aaaabaababa
baaaabaaa -> aaaabaababaaabaababbbba
baaaaa -> aaaabaababaaabaababbbbaabaababbbba

# < a,b | baaaabaabbaabba=a >
baaaabaabbaabba -> a
baaaabaabbaaba -> aaaabaabbaabba
baaaabaabbaaa -> aaaabaabbaaba
baaaabaaba -> aaaabaabbaabaabaabbaabba
baaaabaaa -> aaaabaabbaabaabaabbaaba
baaaaa -> aaaabaabbaabaabaabbaabaabaabbaabba

# < a,b | baaaabaabbababa=a >
baaaabaabbababa -> a
baaaabaabbabaa -> aaaabaabbababa
baaaabaabbaa -> aaaabaabbababaaabaabbababa
baaaabaaba -> aaaabaabbababaaabaabbababaaabaabbababa
baaaabaaa -> aaaabaabbababaaabaabbababaaabaabbabaa
baaaaa -> aaaabaabbababaaabaabbababaaabaabbabaaabaabbababa

# < a,b | baaaabaabbabbba=a >
baaaabaabbabbba -> a
baaaabaabbabba -> aaaabaabbabbba
baaaabaabbaba -> aaaabaabbabba
baaaabaabbaa -> aaaabaabbaba
baaaabaaba -> aaaabaabbabaaabaabbabbba
baaaabaaa -> aaaabaabbabaaabaabbabba
baaaaa -> aaaabaabbabaaabaabbabbaabaabbabbba

# < a,b | baaaabaabbbabba=a >
baaaabaabbbabba -> a
baaaabaabbbaba -> aaaabaabbbabba
baaaabaabbbaa -> aaaabaabbbaba
baaaabaabba -> aaaabaabbbabaaabaabbbabba
baaaabaaba -> aaaabaabbbabaaabaabbbaba
baaaabaaa -> aaaabaabbbabaaabaabbbaa
baaaaa -> aaaabaabbbabaaabaabbbaaabaabbbabba

# < a,b | baaaabaabbbbbba=a >
baaaabaabbbbbba -> a
baaaabaabbbbba -> aaaabaabbbbbba
baaaabaabbbba -> aaaabaabbbbba
baaaabaabbba -> aaaabaabbbba
baaaabaabba -> aaaabaabbba
baaaabaaba -> aaaabaabba
baaaabaaa -> aaaabaaba
baaaaa -> aaaabaabaabaabbbbbba

# < a,b | baaaababaaaabba=a >
baaaababaaaabba -> a
baaaababaaaaba -> aaaababaaaabba
baaaabaa -> aaaababaaaabbabaaaabba
baaaaa -> aaaababaaaabbabaaaabbaaababaaaabba

# < a,b | baaaababaaababa=a >
baaaababaaababa -> a
baaaababaaabaa -> aaaababaaababa
baaaababaaaa -> aaaababaaababaaababaaababa
baaaabaa -> aaaababaaababaaababaaababababaaababa
baaaaa -> aaaababaaababaaababaaababababaaababaaababaaababa

# < a,b | baaaababaaabbba=a >
baaaababaaabbba -> a
baaaababaaabba -> aaaababaaabbba
baaaababaaaba -> aaaababaaabba
baaaababaaaa -> aaaababaaaba
baaaabaa -> aaaababaaabababaaabbba
baaaaa -> aaaababaaabababaaabbbaaababaaabbba

# < a,b | baaaababaabaaba=a >
baaaababaabaaba -> a
baaaababaabaaa -> aaaababaabaaba
baaaababaaa -> aaaababaabaabaababaabaaba
baaaabaa -> aaaababaabaabaababaabaabaababaabaaba
baaaaa -> aaaababaabaabaababaabaabaababaabaabaaababaabaaba

# < a,b | baaaababaababaa=a >
baaaababaababaa -> a
baaaababaabaa -> aaababaababaa
baaaababaaa -> aaababaabaa
baaaabaa -> aaababaabaaababaababaa
baaaaa -> aaababaabaaababaabaa

# < a,b | baaaababaababba=a >
baaaababaababba -> a
baaaababaababa -> aaaababaababba
baaaababaabaa -> aaaababaababa
baaaababaaa -> aaaababaababaaababaababba
baaaabaa -> aaaababaababaaababaababbaababaababba
baaaaa -> aaaababaababaaababaababbaababaababbaaababaababba

# < a,b | baaaababaabbaba=a >
baaaababaabbaba -> a
baaaababaabbaa -> aaaababaabbaba
baaaababaaba -> aaaababaabbabaaababaabbaba
baaaababaaa -> aaaababaabbabaaababaabbaa
baaaabaa -> aaaababaabbabaaababaabbaaababaabbaba
baaaaa -> aaaababaabbabaaababaabbaaababaabbabaaababaabbaba

# < a,b | baaaababaabbbba=a >
baaaababaabbbba -> a
baaaababaabbba -> aaaababaabbbba
baaaababaabba -> aaaababaabbba
baaaababaaba -> aaaababaabba
baaaababaaa -> aaaababaaba
baaaabaa -> aaaababaabaababaabbbba
baaaaa -> aaaababaabaababaabbbbaaababaabbbba

# < a,b | baaaabababaaaba=a >
baaaabababaaaba -> a
baaaabababaaaa -> aaaabababaaaba
baaaababaa -> aaaabababaaababababaaaba
baaaabaa -> aaaabababaaababababaaabaaabababaaaba
baaaaa -> aaaabababaaababababaaabaaabababaaabaaabababaaaba

# < a,b | baaaabababaabba=a >
baaaabababaabba -> a
baaaabababaaba -> aaaabababaabba
baaaabababaaa -> aaaabababaaba
baaaababaa -> aaaabababaabaabababaabba
baaaabaa -> aaaabababaabaabababaabbaaabababaabba
baaaaa -> aaaabababaabaabababaabbaaabababaabbaaabababaabba

# < a,b | baaaabababababa=a >
baaaabababababa -> a
baaaababababaa -> aaaabababababa
baaaabababaa -> aaaabababababaaabababababa
baaaababaa -> aaaabababababaaabababababaaabababababa
baaaabaa -> aaaabababababaaabababababaaabababababaaabababababa
baaaaa -> aaaabababababaaabababababaaabababababaaabababababaaabababababa

# < a,b | baaaababababbba=a >
baaaababababbba -> a
baaaababababba -> aaaababababbba
baaaababababa -> aaaababababba
baaaabababaa -> aaaababababa
baaaababaa -> aaaababababaaababababbba
baaaabaa -> aaaababababaaababababbbaaababababbba
baaaaa -> aaaababababaaababababbbaaababababbbaaababababbba

# < a,b | baaaabababbabba=a >
baaaabababbabba -> a
baaaabababbaba -> aaaabababbabba
baaaabababbaa -> aaaabababbaba
baaaabababa -> aaaabababbabaaabababbabba
baaaababaa -> aaaabababbabaaabababbaba
baaaabaa -> aaaabababbabaaabababbabaaabababbabba
baaaaa -> aaaabababbabaaabababbabaaabababbabbaaabababbabba

# < a,b | baaaabababbbbba=a >
baaaabababbbbba -> a
baaaabababbbba -> aaaabababbbbba
baaaabababbba -> aaaabababbbba
baaaabababba -> aaaabababbba
baaaabababa -> aaaabababba
baaaababaa -> aaaabababa
baaaabaa -> aaaabababaaabababbbbba
baaaaa -> aaaabababaaabababbbbbaaabababbbbba

# < a,b | baaaababbaaabba=a >
baaaababbaaabba -> a
baaaababbaaaba -> aaaababbaaabba
baaaababbaaaa -> aaaababbaaaba
baaaababa -> aaaababbaaabababbaaabba
baaaabaa -> aaaababbaaabababbaaaba
baaaaa -> aaaababbaaabababbaaabaaababbaaabba

# < a,b | baaaababbaababa=a >
baaaababbaababa -> a
baaaababbaabaa -> aaaababbaababa
baaaababbaaa -> aaaababbaababaaababbaababa
baaaababa -> aaaababbaababaaababbaababaababbaababa
baaaabaa -> aaaababbaababaaababbaababaababbaabaa
baaaaa -> aaaababbaababaaababbaababaababbaaa

# < a,b | baaaababbaabbba=a >
baaaababbaabbba -> a
baaaababbaabba -> aaaababbaabbba
baaaababbaaba -> aaaababbaabba
baaaababbaaa -> aaaababbaaba
baaaababa -> aaaababbaabaababbaabbba
baaaabaa -> aaaababbaabaababbaabba
baaaaa -> aaaababbaabaababbaabbaaababbaabbba

# < a,b | baaaababbababba=a >
baaaababbababba -> a
baaaababbababa -> aaaababbababba
baaaababbabaa -> aaaababbababa
baaaababbaa -> aaaababbababaaababbababba
baaaababa -> aaaababbababaaababbababbaaababbababba
baaaabaa -> aaaababbababaaababbababbaaababbababa
baaaaa -> aaaababbababaaababbababbaaababbababaaababbababba

# < a,b | baaaababbabbaba=a >
baaaababbabbaba -> a
baaaababbabbaa -> aaaababbabbaba
baaaababbaba -> aaaababbabbabaaababbabbaba
baaaababbaa -> aaaababbabbabaaababbabbaa
baaaababa -> aaaababbabbabaaababbaba
baaaabaa -> aaaababbabbabaaababbaa
baaaaa -> aaaababbabbabaaababa

# < a,b | baaaababbabbbba=a >
baaaababbabbbba -> a
baaaababbabbba -> aaaababbabbbba
baaaababbabba -> aaaababbabbba
baaaababbaba -> aaaababbabba
baaaababbaa -> aaaababbaba
baaaababa -> aaaababbabaaababbabbbba
baaaabaa -> aaaababbabaaababbabbba
baaaaa -> aaaababbabaaababbabbbaaababbabbbba

# < a,b | baaaababbbabbba=a >
baaaababbbabbba -> a
baaaababbbabba -> aaaababbbabbba
baaaababbbaba -> aaaababbbabba
baaaababbbaa -> aaaababbbaba
baaaababba -> aaaababbbabaaababbbabbba
baaaababa -> aaaababbbabaaababbbabba
baaaabaa -> aaaababbbabaaababbbaba
baaaaa -> aaaababbbabaaababbbabaaababbbabbba

# < a,b | baaaababbbbbbba=a >
baaaababbbbbbba -> a
baaaababbbbbba -> aaaababbbbbbba
baaaababbbbba -> aaaababbbbbba
baaaababbbba -> aaaababbbbba
baaaababbba -> aaaababbbba
baaaababba -> aaaababbba
baaaababa -> aaaababba
baaaabaa -> aaaababa
baaaaa -> aaaababaaababbbbbbba

# < a,b | baaaabbaaaababa=a >
baaaabbaaaababa -> a
baaaabbaaaabaa -> aaaabbaaaababa
baaaabbaaaaa -> aaaabbaaaababaaabbaaaababa

# < a,b | baaaabbaaaabbba=a >
baaaabbaaaabbba -> a
baaaabbaaaabba -> aaaabbaaaabbba
baaaaba -> aaaabbaaaabbbaaaabbba
baaaaa -> aaaabbaaaabbbaaaabba

# < a,b | baaaabbaaabaaba=a >
baaaabbaaabaaba -> a
baaaabbaaabaaa -> aaaabbaaabaaba
baaaabbaaaa -> aaaabbaaabaabaabbaaabaaba
baaaaba -> aaaabbaaabaabaabbaaabaababbaaabaaba
baaaaa -> aaaabbaaabaabaabbaaabaababbaaabaaa

# < a,b | baaaabbaaababba=a >
baaaabbaaababba -> a
baaaabbaaababa -> aaaabbaaababba
baaaabbaaabaa -> aaaabbaaababa
baaaabbaaaa -> aaaabbaaababaaabbaaababba
baaaaba -> aaaabbaaababaaabbaaababbabbaaababba
baaaaa -> aaaabbaaababaaabbaaababbabbaaababa

# < a,b | baaaabbaaabbaba=a >
baaaabbaaabbaba -> a
baaaabbaaabbaa -> aaaabbaaabbaba
baaaabbaaaba -> aaaabbaaabbabaaabbaaabbaba
baaaabbaaaa -> aaaabbaaabbabaaabbaaabbaa
baaaaba -> aaaabbaaabbabaaabbaaabbaabbaaabbaba
baaaaa -> aaaabbaaabbabaaabbaaabbaabbaaabbaa

# < a,b | baaaabbaaabbbba=a >
baaaabbaaabbbba -> a
baaaabbaaabbba -> aaaabbaaabbbba
baaaabbaaabba -> aaaabbaaabbba
baaaabbaaaba -> aaaabbaaabba
baaaabbaaaa -> aaaabbaaaba
baaaaba -> aaaabbaaababbaaabbbba
baaaaa -> aaaabbaaababbaaabbba

# < a,b | baaaabbaabaaaba=a >
baaaabbaabaaaba -> a
baaaabbaabaaaa -> aaaabbaabaaaba
baaaabbaaa -> aaaabbaabaaababbaabaaaba
baaaaba -> aaaabbaabaaababbaabaaabaabbaabaaaba
baaaaa -> aaaabbaabaaababbaabaaabaabbaabaaaa

# < a,b | baaaabbaabaabba=a >
baaaabbaabaabba -> a
baaaabbaabaaba -> aaaabbaabaabba
baaaabbaabaaa -> aaaabbaabaaba
baaaabbaaa -> aaaabbaabaabaabbaabaabba
baaaaba -> aaaabbaabaabaabbaabaabbaabbaabaabba
baaaaa -> aaaabbaabaabaabbaabaabbaabbaabaaba

# < a,b | baaaabbaabababa=a >
baaaabbaabababa -> a
baaaabbaababaa -> aaaabbaabababa
baaaabbaabaa -> aaaabbaabababaaabbaabababa
baaaabbaaa -> aaaabbaabababaaabbaabababaaabbaabababa
baaaaba -> aaaabbaabababaaabbaabababaaabbaabababaabbaabababa
baaaaa -> aaaabbaabababaaabbaabababaaabbaabababaabbaababaa

# < a,b | baaaabbaababbba=a >
baaaabbaababbba -> a
baaaabbaababba -> aaaabbaababbba
baaaabbaababa -> aaaabbaababba
baaaabbaabaa -> aaaabbaababa
baaaabbaaa -> aaaabbaababaaabbaababbba
baaaaba -> aaaabbaababaaabbaababbbaabbaababbba
baaaaa -> aaaabbaababaaabbaababbbaabbaababba

# < a,b | baaaabbaabbaaba=a >
baaaabbaabbaaba -> a
baaaabbaabbaaa -> aaaabbaabbaaba
baaaabbaaba -> aaaabbaabbaabaabbaabbaaba
baaaabbaaa -> aaaabbaabbaabaabbaabbaaa
baaaaba -> aaaabbaabbaabaabbaaba
baaaaa -> aaaabbaabbaabaabbaaa

# < a,b | baaaabbaabbabba=a >
baaaabbaabbabba -> a
baaaabbaabbaba -> aaaabbaabbabba
baaaabbaabbaa -> aaaabbaabbaba
baaaabbaaba -> aaaabbaabbabaaabbaabbabba
baaaabbaaa -> aaaabbaabbabaaabbaabbaba
baaaaba -> aaaabbaabbabaaabbaabbabaabbaabbabba
baaaaa -> aaaabbaabbabaaabbaabbabaabbaabbaba

# < a,b | baaaabbaabbbbba=a >
baaaabbaabbbbba -> a
baaaabbaabbbba -> aaaabbaabbbbba
baaaabbaabbba -> aaaabbaabbbba
baaaabbaabba -> aaaabbaabbba
baaaabbaaba -> aaaabbaabba
baaaabbaaa -> aaaabbaaba
baaaaba -> aaaabbaabaabbaabbbbba
baaaaa -> aaaabbaabaabbaabbbba

# < a,b | baaaabbabaaabba=a >
baaaabbabaaabba -> a
baaaabbabaaaba -> aaaabbabaaabba
baaaabbabaaaa -> aaaabbabaaaba
baaaabbaa -> aaaabbabaaababbabaaabba
baaaaba -> aaaabbabaaababbabaaabbaaabbabaaabba
baaaaa -> aaaabbabaaababbabaaabbaaabbabaaaba

# < a,b | baaaabbabaababa=a >
baaaabbabaababa -> a
baaaabbabaabaa -> aaaabbabaababa
baaaabbabaaa -> aaaabbabaababaaabbabaababa
baaaabbaa -> aaaabbabaababaaabbabaababaabbabaababa
baaaaba -> aaaabbabaababaaabbabaababaabbabaababaaabbabaababa
baaaaa -> aaaabbabaababaaabbabaababaabbabaababaaabbabaabaa

# < a,b | baaaabbabaabbba=a >
baaaabbabaabbba -> a
baaaabbabaabba -> aaaabbabaabbba
baaaabbabaaba -> aaaabbabaabba
baaaabbabaaa -> aaaabbabaaba
baaaabbaa -> aaaabbabaabaabbabaabbba
baaaaba -> aaaabbabaabaabbabaabbbaaabbabaabbba
baaaaa -> aaaabbabaabaabbabaabbbaaabbabaabba

# < a,b | baaaabbababaaba=a >
baaaabbababaaba -> a
baaaabbababaaa -> aaaabbababaaba
baaaabbabaa -> aaaabbababaabaabbababaaba
baaaabbaa -> aaaabbababaabaabbababaabaaabbababaaba
baaaaba -> aaaabbababaabaabbababaabaaabbababaabaaabbababaaba
baaaaa -> aaaabbababaabaabbababaabaaabbababaabaaabbababaaa

# < a,b | baaaabbabababba=a >
baaaabbabababba -> a
baaaabbabababa -> aaaabbabababba
baaaabbababaa -> aaaabbabababa
baaaabbabaa -> aaaabbabababaaabbabababba
baaaabbaa -> aaaabbabababaaabbabababbaaabbabababba
baaaaba -> aaaabbabababaaabbabababbaaabbabababbaaabbabababba
baaaaa -> aaaabbabababaaabbabababbaaabbabababbaaabbabababa

# < a,b | baaaabbababbaba=a >
baaaabbababbaba -> a
baaaabbababbaa -> aaaabbababbaba
baaaabbababa -> aaaabbababbabaaabbababbaba
baaaabbabaa -> aaaabbababbabaaabbababbaa
baaaabbaa -> aaaabbababbabaaabbababa
baaaaba -> aaaabbababbabaaabbababaaabbababbaba
baaaaa -> aaaabbababbabaaabbababaaabbababbaa

# < a,b | baaaabbababbbba=a >
baaaabbababbbba -> a
baaaabbababbba -> aaaabbababbbba
baaaabbababba -> aaaabbababbba
baaaabbababa -> aaaabbababba
baaaabbabaa -> aaaabbababa
baaaabbaa -> aaaabbababaaabbababbbba
baaaaba -> aaaabbababaaabbababbbbaaabbababbbba
baaaaa -> aaaabbababaaabbababbbbaaabbababbba

# < a,b | baaaabbabbaabba=a >
baaaabbabbaabba -> a
baaaabbabbaaba -> aaaabbabbaabba
baaaabbabbaaa -> aaaabbabbaaba
baaaabbaba -> aaaabbabbaabaabbabbaabba
baaaabbaa -> aaaabbabbaabaabbabbaaba
baaaaba -> aaaabbabbaabaabbabbaabaaabbabbaabba
baaaaa -> aaaabbabbaabaabbabbaabaaabbabbaaba

# < a,b | baaaabbabbabbba=a >
baaaabbabbabbba -> a
baaaabbabbabba -> aaaabbabbabbba
baaaabbabbaba -> aaaabbabbabba
baaaabbabbaa -> aaaabbabbaba
baaaabbaba -> aaaabbabbabaaabbabbabbba
baaaabbaa -> aaaabbabbabaaabbabbabba
baaaaba -> aaaabbabbabaaabbabbabbaaabbabbabbba
baaaaa -> aaaabbabbabaaabbabbabbaaabbabbabba

# < a,b | baaaabbabbbabba=a >
baaaabbabbbabba -> a
baaaabbabbbaba -> aaaabbabbbabba
baaaabbabbbaa -> aaaabbabbbaba
baaaabbabba -> aaaabbabbbabaaabbabbbabba
baaaabbaba -> aaaabbabbbabaaabbabbbaba
baaaabbaa -> aaaabbabbbabaaabbabbbaa
baaaaba -> aaaabbabbbabaaabbabba
baaaaa -> aaaabbabbbabaaabbaba

# < a,b | baaaabbabbbbbba=a >
baaaabbabbbbbba -> a
baaaabbabbbbba -> aaaabbabbbbbba
baaaabbabbbba -> aaaabbabbbbba
baaaabbabbba -> aaaabbabbbba
baaaabbabba -> aaaabbabbba
baaaabbaba -> aaaabbabba
baaaabbaa -> aaaabbaba
baaaaba -> aaaabbabaaabbabbbbbba
baaaaa -> aaaabbabaaabbabbbbba

# < a,b | baaaabbbaaabbba=a >
baaaabbbaaabbba -> a
baaaabbbaaabba -> aaaabbbaaabbba
baaaabbbaaaba -> aaaabbbaaabba
baaaabbbaaaa -> aaaabbbaaaba
baaaabba -> aaaabbbaaababbbaaabbba
baaaaba -> aaaabbbaaababbbaaabba
baaaaa -> aaaabbbaaababbbaaaba

# < a,b | baaaabbbaababba=a >
baaaabbbaababba -> a
baaaabbbaababa -> aaaabbbaababba
baaaabbbaabaa -> aaaabbbaababa
baaaabbbaaa -> aaaabbbaababaaabbbaababba
baaaabba -> aaaabbbaababaaabbbaababbaabbbaababba
baaaaba -> aaaabbbaababaaabbbaababbaabbbaababa
baaaaa -> aaaabbbaababaaabbbaababbaabbbaabaa

# < a,b | baaaabbbaabbbba=a >
baaaabbbaabbbba -> a
baaaabbbaabbba -> aaaabbbaabbbba
baaaabbbaabba -> aaaabbbaabbba
baaaabbbaaba -> aaaabbbaabba
baaaabbbaaa -> aaaabbbaaba
baaaabba -> aaaabbbaabaabbbaabbbba
baaaaba -> aaaabbbaabaabbbaabbba
baaaaa -> aaaabbbaabaabbbaabba

# < a,b | baaaabbbabaabba=a >
baaaabbbabaabba -> a
baaaabbbabaaba -> aaaabbbabaabba
baaaabbbabaaa -> aaaabbbabaaba
baaaabbbaa -> aaaabbbabaabaabbbabaabba
baaaabba -> aaaabbbabaabaabbbabaabbaaabbbabaabba
baaaaba -> aaaabbbabaabaabbbabaabbaaabbbabaaba
baaaaa -> aaaabbbabaabaabbbabaabbaaabbbabaaa

# < a,b | baaaabbbababbba=a >
baaaabbbababbba -> a
baaaabbbababba -> aaaabbbababbba
baaaabbbababa -> aaaabbbababba
baaaabbbabaa -> aaaabbbababa
baaaabbbaa -> aaaabbbababaaabbbababbba
baaaabba -> aaaabbbababaaabbbababbbaaabbbababbba
baaaaba -> aaaabbbababaaabbbababbbaaabbbababba
baaaaa -> aaaabbbababaaabbbababbbaaabbbababa

# < a,b | baaaabbbabbabba=a >
baaaabbbabbabba -> a
baaaabbbabbaba -> aaaabbbabbabba
baaaabbbabbaa -> aaaabbbabbaba
baaaabbbaba -> aaaabbbabbabaaabbbabbabba
baaaabbbaa -> aaaabbbabbabaaabbbabbaba
baaaabba -> aaaabbbabbabaaabbbabbabaaabbbabbabba
baaaaba -> aaaabbbabbabaaabbbabbabaaabbbabbaba
baaaaa -> aaaabbbabbabaaabbbabbabaaabbbabbaa

# < a,b | baaaabbbabbbbba=a >
baaaabbbabbbbba -> a
baaaabbbabbbba -> aaaabbbabbbbba
baaaabbbabbba -> aaaabbbabbbba
baaaabbbabba -> aaaabbbabbba
baaaabbbaba -> aaaabbbabba
baaaabbbaa -> aaaabbbaba
baaaabba -> aaaabbbabaaabbbabbbbba
baaaaba -> aaaabbbabaaabbbabbbba
baaaaa -> aaaabbbabaaabbbabbba

# < a,b | baaaabbbbaabbba=a >
baaaabbbbaabbba -> a
baaaabbbbaabba -> aaaabbbbaabbba
baaaabbbbaaba -> aaaabbbbaabba
baaaabbbbaaa -> aaaabbbbaaba
baaaabbba -> aaaabbbbaabaabbbbaabbba
baaaabba -> aaaabbbbaabaabbbbaabba
baaaaba -> aaaabbbbaabaabbbbaaba
baaaaa -> aaaabbbbaabaabbbbaaa

# < a,b | baaaabbbbabbbba=a >
baaaabbbbabbbba -> a
baaaabbbbabbba -> aaaabbbbabbbba
baaaabbbbabba -> aaaabbbbabbba
baaaabbbbaba -> aaaabbbbabba
baaaabbbbaa -> aaaabbbbaba
baaaabbba -> aaaabbbbabaaabbbbabbbba
baaaabba -> aaaabbbbabaaabbbbabbba
baaaaba -> aaaabbbbabaaabbbbabba
baaaaa -> aaaabbbbabaaabbbbaba

# < a,b | baaabaaaaaababa=a >
baaabaaaaaababa -> a
baaabaaaaaabaa -> aaabaaaaaababa
baaabaaaaaaa -> aaabaaaaaababaabaaaaaababa

# < a,b | baaabaaaaaabbaa=a >
baaabaaaaaabbaa -> a
baaabaaaaaaba -> aabaaaaaabbaa
baaabaaaaaaa -> aabaaaaaabbaaaabaaaaaabbaa

# < a,b | baaabaaaaabaaba=a >
baaabaaaaabaaba -> a
baaabaaaaabaaa -> aaabaaaaabaaba
baaabaaaaaa -> aaabaaaaabaababaaaaabaaba

# < a,b | baaabaaaaababba=a >
baaabaaaaababba -> a
baaabaaaaababa -> aaabaaaaababba
baaabaaaaabaa -> aaabaaaaababa
baaabaaaaaa -> aaabaaaaababaabaaaaababba

# < a,b | baaabaaaaabbaaa=a >
baaabaaaaabbaaa -> a
baaabaaaaaba -> abaaaaabbaaa
baaabaaaaaa -> abaaaaabbaaaaabaaaaabbaaa

# < a,b | baaabaaaaabbaba=a >
baaabaaaaabbaba -> a
baaabaaaaabbaa -> aaabaaaaabbaba
baaabaaaaaba -> aaabaaaaabbabaabaaaaabbaba
baaabaaaaaa -> aaabaaaaabbabaabaaaaabbaa

# < a,b | baaabaaaaabbbaa=a >
baaabaaaaabbbaa -> a
baaabaaaaabba -> aabaaaaabbbaa
baaabaaaaaba -> aabaaaaabbbaaaabaaaaabbbaa
baaabaaaaaa -> aabaaaaabbbaaaabaaaaabbbaaaabaaaaabbbaa

# < a,b | baaabaaaabaabaa=a >
baaabaaaabaabaa -> a
baaabaaaabaaa -> aabaaaabaabaa
baaabaaaaa -> aabaaaabaabaabaaaabaabaa

# < a,b | baaabaaaabaabba=a >
baaabaaaabaabba -> a
baaabaaaabaaba -> aaabaaaabaabba
baaabaaaabaaa -> aaabaaaabaaba
baaabaaaaa -> aaabaaaabaababaaaabaabba

# < a,b | baaabaaaababaaa=a >
baaabaaaababaaa -> a
baaabaaaabaa -> abaaaababaaa
baaabaaaaa -> abaaaababaaaabaaaababaaa

# < a,b | baaabaaaabababa=a >
baaabaaaabababa -> a
baaabaaaababaa -> aaabaaaabababa
baaabaaaabaa -> aaabaaaabababaabaaaabababa
baaabaaaaa -> aaabaaaabababaabaaaabababaabaaaabababa

# < a,b | baaabaaaababbaa=a >
baaabaaaababbaa -> a
baaabaaaababa -> aabaaaababbaa
baaabaaaabaa -> aabaaaababbaaaabaaaababbaa
baaabaaaaa -> aabaaaababbaaaabaaaababa

# < a,b | baaabaaaababbba=a >
baaabaaaababbba -> a
baaabaaaababba -> aaabaaaababbba
baaabaaaababa -> aaabaaaababba
baaabaaaabaa -> aaabaaaababa
baaabaaaaa -> aaabaaaababaabaaaababbba

# < a,b | baaabaaaabbaaba=a >
baaabaaaabbaaba -> a
baaabaaaabbaaa -> aaabaaaabbaaba
baaabaaaaba -> aaabaaaabbaababaaaabbaaba
baaabaaaaa -> aaabaaaabbaababaaaabbaaa

# < a,b | baaabaaaabbabaa=a >
baaabaaaabbabaa -> a
baaabaaaabbaa -> aabaaaabbabaa
baaabaaaaba -> aabaaaabbaa
baaabaaaaa -> aabaaaabbaaaabaaaabbabaa

# < a,b | baaabaaaabbabba=a >
baaabaaaabbabba -> a
baaabaaaabbaba -> aaabaaaabbabba
baaabaaaabbaa -> aaabaaaabbaba
baaabaaaaba -> aaabaaaabbabaabaaaabbabba
baaabaaaaa -> aaabaaaabbabaabaaaabbaba

# < a,b | baaabaaaabbbaaa=a >
baaabaaaabbbaaa -> a
baaabaaaabba -> abaaaabbbaaa
baaabaaaaba -> abaaaabbbaaaaabaaaabbbaaa
baaabaaaaa -> abaaaabbbaaaaabaaaabbbaaaaabaaaabbbaaa

# < a,b | baaabaaaabbbaba=a >
baaabaaaabbbaba -> a
baaabaaaabbbaa -> aaabaaaabbbaba
baaabaaaabba -> aaabaaaabbbabaabaaaabbbaba
baaabaaaaba -> aaabaaaabbbabaabaaaabbbaa
baaabaaaaa -> aaabaaaabbbabaabaaaabbbaaaabaaaabbbaba

# < a,b | baaabaaaabbbbaa=a >
baaabaaaabbbbaa -> a
baaabaaaabbba -> aabaaaabbbbaa
baaabaaaabba -> aabaaaabbbbaaaabaaaabbbbaa
baaabaaaaba -> aabaaaabbbbaaaabaaaabbbbaaaabaaaabbbbaa
baaabaaaaa -> aabaaaabbbbaaaabaaaabbbbaaaabaaaabbbbaaaabaaaabbbbaa

# < a,b | baaabaaabaaabba=a >
baaabaaabaaabba -> a
baaabaaabaaaba -> aaabaaabaaabba
baaaa -> aaabaaabaaabbaaabba

# < a,b | baaabaaabaabaaa=a >
baaabaaabaabaaa -> a
baaabaaabaaa -> abaaabaabaaa
baaaa -> abaaabaabaaabaabaaa

# < a,b | baaabaaabaababa=a >
baaabaaabaababa -> a
baaabaaabaabaa -> aaabaaabaababa
baaabaaabaaa -> aaabaaabaababaabaaabaababa
baaaa -> aaabaaabaababaabaaabaabababaababa

# < a,b | baaabaaabaabbba=a >
baaabaaabaabbba -> a
baaabaaabaabba -> aaabaaabaabbba
baaabaaabaaba -> aaabaaabaabba
baaabaaabaaa -> aaabaaabaaba
baaaa -> aaabaaabaababaabbba

# < a,b | baaabaaababaaba=a >
baaabaaababaaba -> a
baaabaaababaaa -> aaabaaababaaba
baaabaaabaa -> aaabaaababaababaaababaaba
baaaa -> aaabaaababaababaaababaabaababaaba

# < a,b | baaabaaabababaa=a >
baaabaaabababaa -> a
baaabaaababaa -> aabaaabababaa
baaabaaabaa -> aabaaababaa
baaaa -> aabaaababaaabababaa

# < a,b | baaabaaabababba=a >
baaabaaabababba -> a
baaabaaabababa -> aaabaaabababba
baaabaaababaa -> aaabaaabababa
baaabaaabaa -> aaabaaabababaabaaabababba
baaaa -> aaabaaabababaabaaabababbaabababba

# < a,b | baaabaaababbaba=a >
baaabaaababbaba -> a
baaabaaababbaa -> aaabaaababbaba
baaabaaababa -> aaabaaababbabaabaaababbaba
baaabaaabaa -> aaabaaababbabaabaaababbaa
baaaa -> aaabaaababbabaabaaababbaaababbaba

# < a,b | baaabaaababbbba=a >
baaabaaababbbba -> a
baaabaaababbba -> aaabaaababbbba
baaabaaababba -> aaabaaababbba
baaabaaababa -> aaabaaababba
baaabaaabaa -> aaabaaababa
baaaa -> aaabaaababaababbbba

# < a,b | baaabaaabbaabba=a >
baaabaaabbaabba -> a
baaabaaabbaaba -> aaabaaabbaabba
baaabaaabbaaa -> aaabaaabbaaba
baaabaaaba -> aaabaaabbaababaaabbaabba
baaaa -> aaabaaabbaababaaabbaabbaaabbaabba

# < a,b | baaabaaabbababa=a >
baaabaaabbababa -> a
baaabaaabbabaa -> aaabaaabbababa
baaabaaabbaa -> aaabaaabbababaabaaabbababa
baaabaaaba -> aaabaaabbababaabaaabbababaabaaabbababa
baaaa -> aaabaaabbababaabaaabbababaabaaabbababaaabbababa

# < a,b | baaabaaabbabbba=a >
baaabaaabbabbba -> a
baaabaaabbabba -> aaabaaabbabbba
baaabaaabbaba -> aaabaaabbabba
baaabaaabbaa -> aaabaaabbaba
baaabaaaba -> aaabaaabbabaabaaabbabbba
baaaa -> aaabaaabbabaabaaabbabbbaaabbabbba

# < a,b | baaabaaabbbabba=a >
baaabaaabbbabba -> a
baaabaaabbbaba -> aaabaaabbbabba
baaabaaabbbaa -> aaabaaabbbaba
baaabaaabba -> aaabaaabbbabaabaaabbbabba
baaabaaaba -> aaabaaabbbabaabaaabbbaba
baaaa -> aaabaaabbbabaabaaabbbabaaabbbabba

# < a,b | baaabaaabbbbbba=a >
baaabaaabbbbbba -> a
baaabaaabbbbba -> aaabaaabbbbbba
baaabaaabbbba -> aaabaaabbbbba
baaabaaabbba -> aaabaaabbbba
baaabaaabba -> aaabaaabbba
baaabaaaba -> aaabaaabba
baaaa -> aaabaaabbaaabbbbbba

# < a,b | baaabaabaaababa=a >
baaabaabaaababa -> a
baaabaabaaabaa -> aaabaabaaababa
baaabaaa -> aaabaabaaabababaaababa
baaaa -> aaabaabaaabababaaabababaabaaababa

# < a,b | baaabaabaaabbba=a >
baaabaabaaabbba -> a
baaabaabaaabba -> aaabaabaaabbba
baaabaabaaaba -> aaabaabaaabba
baaabaaa -> aaabaabaaabbaabaaabbba
baaaa -> aaabaabaaabbaabaaabbbabaabaaabbba

# < a,b | baaabaabaabaaba=a >
baaabaabaabaaba -> a
baaabaabaabaaa -> aaabaabaabaaba
baaabaabaaa -> aaabaabaabaababaabaabaaba
baaabaaa -> aaabaabaabaababaabaabaababaabaabaaba
baaaa -> aaabaabaabaababaabaabaababaabaabaababaabaabaaba

# < a,b | baaabaabaababaa=a >
baaabaabaababaa -> a
baaabaabaabaa -> aabaabaababaa
baaabaabaaa -> aabaabaabaa
baaabaaa -> aabaabaabaabaabaababaa
baaaa -> aabaabaabaabaabaababaabaabaababaa

# < a,b | baaabaabaababba=a >
baaabaabaababba -> a
baaabaabaababa -> aaabaabaababba
baaabaabaabaa -> aaabaabaababa
baaabaabaaa -> aaabaabaababaabaabaababba
baaabaaa -> aaabaabaababaabaabaababbabaabaababba
baaaa -> aaabaabaababaabaabaababbabaabaababbabaabaababba

# < a,b | baaabaabaabbaba=a >
baaabaabaabbaba -> a
baaabaabaabbaa -> aaabaabaabbaba
baaabaabaaba -> aaabaabaabbabaabaabaabbaba
baaabaabaaa -> aaabaabaabbabaabaabaabbaa
baaabaaa -> aaabaabaabbabaabaabaabbaabaabaabbaba
baaaa -> aaabaabaabbabaabaabaabbaabaabaabbababaabaabbaba

# < a,b | baaabaabaabbbba=a >
baaabaabaabbbba -> a
baaabaabaabbba -> aaabaabaabbbba
baaabaabaabba -> aaabaabaabbba
baaabaabaaba -> aaabaabaabba
baaabaabaaa -> aaabaabaaba
baaabaaa -> aaabaabaababaabaabbbba
baaaa -> aaabaabaababaabaabbbbabaabaabbbba

# < a,b | baaabaababaaaba=a >
baaabaababaaaba -> a
baaabaabaa -> aababaaaba
baaabaaa -> aabaaababaaabababaaaba
baaaa -> aabaaababaaabababaaababaababaaaba

# < a,b | baaabaababaabaa=a >
baaabaababaabaa -> a
baaabaababaaa -> aabaababaabaa
baaabaabaa -> aabaababaabaabaababaabaa
baaabaaa -> aabaababaabaabaababaaa
baaaa -> aabaababaabaabaabaa

# < a,b | baaabaababaabba=a >
baaabaababaabba -> a
baaabaababaaba -> aaabaababaabba
baaabaababaaa -> aaabaababaaba
baaabaabaa -> aaabaababaababaababaabba
baaabaaa -> aaabaababaababaababaabbaabaababaabba
baaaa -> aaabaababaababaababaabbaabaababaabbabaababaabba

# < a,b | baaabaababababa=a >
baaabaababababa -> a
baaabaabababaa -> aaabaababababa
baaabaababaa -> aaabaababababaabaababababa
baaabaabaa -> aaabaababababaabaababababaabaababababa
baaabaaa -> aaabaababababaabaababababaabaababababaabaababababa
baaaa -> aaabaababababaabaababababaabaababababaabaabababababaababababa

# < a,b | baaabaabababbba=a >
baaabaabababbba -> a
baaabaabababba -> aaabaabababbba
baaabaabababa -> aaabaabababba
baaabaababaa -> aaabaabababa
baaabaabaa -> aaabaabababaabaabababbba
baaabaaa -> aaabaabababaabaabababbbaabaabababbba
baaaa -> aaabaabababaabaabababbbaabaabababbbabaabababbba

# < a,b | baaabaababbabba=a >
baaabaababbabba -> a
baaabaababbaba -> aaabaababbabba
baaabaababbaa -> aaabaababbaba
baaabaababa -> aaabaababbabaabaababbabba
baaabaabaa -> aaabaababbabaabaababbaba
baaabaaa -> aaabaababbabaabaababbabaabaababbabba
baaaa -> aaabaababbabaabaababbabaabaababbabbabaababbabba

# < a,b | baaabaababbbbba=a >
baaabaababbbbba -> a
baaabaababbbba -> aaabaababbbbba
baaabaababbba -> aaabaababbbba
baaabaababba -> aaabaababbba
baaabaababa -> aaabaababba
baaabaabaa -> aaabaababa
baaabaaa -> aaabaababaabaababbbbba
baaaa -> aaabaababaabaababbbbbabaababbbbba

# < a,b | baaabaabbaaabba=a >
baaabaabbaaabba -> a
baaabaabbaaaba -> aaabaabbaaabba
baaabaaba -> aaabaabbaaabbaabbaaabba
baaabaaa -> aaabaabbaaabbaabbaaaba
baaaa -> aaabaabbaaabbaabbaaababaabbaaabba

# < a,b | baaabaabbaababa=a >
baaabaabbaababa -> a
baaabaabbaabaa -> aaabaabbaababa
baaabaabbaaa -> aaabaabbaababaabaabbaababa
baaabaaba -> aaabaabbaababaabaabbaabababaabbaababa
baaabaaa -> aaabaabbaababaabaabbaabababaabbaabaa
baaaa -> aaabaabbaababaabaabbaabababaabbaabaabaabbaababa

# < a,b | baaabaabbaabbba=a >
baaabaabbaabbba -> a
baaabaabbaabba -> aaabaabbaabbba
baaabaabbaaba -> aaabaabbaabba
baaabaabbaaa -> aaabaabbaaba
baaabaaba -> aaabaabbaababaabbaabbba
baaabaaa -> aaabaabbaababaabbaabba
baaaa -> aaabaabbaababaabbaabbabaabbaabbba

# < a,b | baaabaabbabaaba=a >
baaabaabbabaaba -> a
baaabaabbabaaa -> aaabaabbabaaba
baaabaabbaa -> aaabaabbabaababaabbabaaba
baaabaaba -> aaabaabbabaababaabbabaabaabaabbabaaba
baaabaaa -> aaabaabbabaababaabbabaabaabaabbabaaa
baaaa -> aaabaabbabaababaabbabaabaabaabbaa

# < a,b | baaabaabbababba=a >
baaabaabbababba -> a
baaabaabbababa -> aaabaabbababba
baaabaabbabaa -> aaabaabbababa
baaabaabbaa -> aaabaabbababaabaabbababba
baaabaaba -> aaabaabbababaabaabbababbaabaabbababba
baaabaaa -> aaabaabbababaabaabbababbaabaabbababa
baaaa -> aaabaabbababaabaabbababbaabaabbabababaabbababba

# < a,b | baaabaabbabbaba=a >
baaabaabbabbaba -> a
baaabaabbabbaa -> aaabaabbabbaba
baaabaabbaba -> aaabaabbabbabaabaabbabbaba
baaabaabbaa -> aaabaabbabbabaabaabbabbaa
baaabaaba -> aaabaabbabbabaabaabbaba
baaabaaa -> aaabaabbabbabaabaabbaa
baaaa -> aaabaabbabbabaabaabbaabaabbabbaba

# < a,b | baaabaabbabbbba=a >
baaabaabbabbbba -> a
baaabaabbabbba -> aaabaabbabbbba
baaabaabbabba -> aaabaabbabbba
baaabaabbaba -> aaabaabbabba
baaabaabbaa -> aaabaabbaba
baaabaaba -> aaabaabbabaabaabbabbbba
baaabaaa -> aaabaabbabaabaabbabbba
baaaa -> aaabaabbabaabaabbabbbabaabbabbbba

# < a,b | baaabaabbbaabba=a >
baaabaabbbaabba -> a
baaabaabbbaaba -> aaabaabbbaabba
baaabaabbbaaa -> aaabaabbbaaba
baaabaabba -> aaabaabbbaababaabbbaabba
baaabaaba -> aaabaabbbaababaabbbaaba
baaabaaa -> aaabaabbbaababaabbbaaa
baaaa -> aaabaabbbaababaabba

# < a,b | baaabaabbbabbba=a >
baaabaabbbabbba -> a
baaabaabbbabba -> aaabaabbbabbba
baaabaabbbaba -> aaabaabbbabba
baaabaabbbaa -> aaabaabbbaba
baaabaabba -> aaabaabbbabaabaabbbabbba
baaabaaba -> aaabaabbbabaabaabbbabba
baaabaaa -> aaabaabbbabaabaabbbaba
baaaa -> aaabaabbbabaabaabbbababaabbbabbba

# < a,b | baaabaabbbbbbba=a >
baaabaabbbbbbba -> a
baaabaabbbbbba -> aaabaabbbbbbba
baaabaabbbbba -> aaabaabbbbbba
baaabaabbbba -> aaabaabbbbba
baaabaabbba -> aaabaabbbba
baaabaabba -> aaabaabbba
baaabaaba -> aaabaabba
baaabaaa -> aaabaaba
baaaa -> aaabaababaabbbbbbba

# < a,b | baaababaaaababa=a >
baaababaaaababa -> a
baaababaaaabaa -> aaababaaaababa
baaababaaaaa -> aaababaaaababaababaaaababa

# < a,b | baaababaaaabbaa=a >
baaababaaaabbaa -> a
baaababaaaaba -> aababaaaabbaa
baaababaaaaa -> aababaaaabbaaaababaaaabbaa

# < a,b | baaababaaabaaba=a >
baaababaaabaaba -> a
baaababaaabaaa -> aaababaaabaaba
baaababaaaa -> aaababaaabaabababaaabaaba

# < a,b | baaababaaababba=a >
baaababaaababba -> a
baaababaaababa -> aaababaaababba
baaabaa -> aaababaaababbaaababba
baaaa -> aaababaaababbaaababbaababaaababba

# < a,b | baaababaaabbaba=a >
baaababaaabbaba -> a
baaababaaabbaa -> aaababaaabbaba
baaababaaaba -> aaababaaabbabaababaaabbaba
baaabaa -> aaababaaabbabaababaaabbababaaabbaba
baaaa -> aaababaaabbabaababaaabbababaaabbabaababaaabbaba

# < a,b | baaababaaabbbba=a >
baaababaaabbbba -> a
baaababaaabbba -> aaababaaabbbba
baaababaaabba -> aaababaaabbba
baaababaaaba -> aaababaaabba
baaabaa -> aaababaaabbabaaabbbba
baaaa -> aaababaaabbabaaabbbbaababaaabbbba

# < a,b | baaababaabaabaa=a >
baaababaabaabaa -> a
baaababaabaaa -> aababaabaabaa
baaababaaa -> aababaabaabaababaabaabaa
baaabaa -> aababaabaabaababaabaabaababaabaabaa
baaaa -> aababaabaabaababaabaabaababaabaaa

# < a,b | baaababaabaabba=a >
baaababaabaabba -> a
baaababaabaaba -> aaababaabaabba
baaababaabaaa -> aaababaabaaba
baaababaaa -> aaababaabaabababaabaabba
baaabaa -> aaababaabaabababaabaabbababaabaabba
baaaa -> aaababaabaabababaabaabbababaabaabbaababaabaabba

# < a,b | baaababaabababa=a >
baaababaabababa -> a
baaababaababaa -> aaababaabababa
baaababaabaa -> aaababaabababaababaabababa
baaababaaa -> aaababaabababaababaabababaababaabababa
baaabaa -> aaababaabababaababaabababaababaabababababaabababa
baaaa -> aaababaabababaababaabababaababaabababababaabababaababaabababa

# < a,b | baaababaababbba=a >
baaababaababbba -> a
baaababaababba -> aaababaababbba
baaababaababa -> aaababaababba
baaababaabaa -> aaababaababa
baaababaaa -> aaababaababaababaababbba
baaabaa -> aaababaababaababaababbbababaababbba
baaaa -> aaababaababaababaababbbababaababbbaababaababbba

# < a,b | baaababaabbaaba=a >
baaababaabbaaba -> a
baaababaabbaaa -> aaababaabbaaba
baaababaaba -> aaababaabbaabababaabbaaba
baaababaaa -> aaababaabbaabababaabbaaa
baaabaa -> aaababaabbaabababaaba
baaaa -> aaababaabbaabababaabaababaabbaaba

# < a,b | baaababaabbabba=a >
baaababaabbabba -> a
baaababaabbaba -> aaababaabbabba
baaababaabbaa -> aaababaabbaba
baaababaaba -> aaababaabbabaababaabbabba
baaababaaa -> aaababaabbabaababaabbaba
baaabaa -> aaababaabbabaababaabbabababaabbabba
baaaa -> aaababaabbabaababaabbabababaabbabbaababaabbabba

# < a,b | baaababaabbbbba=a >
baaababaabbbbba -> a
baaababaabbbba -> aaababaabbbbba
baaababaabbba -> aaababaabbbba
baaababaabba -> aaababaabbba
baaababaaba -> aaababaabba
baaababaaa -> aaababaaba
baaabaa -> aaababaabababaabbbbba
baaaa -> aaababaabababaabbbbbaababaabbbbba

# < a,b | baaabababaaabba=a >
baaabababaaabba -> a
baaabababaaaba -> aaabababaaabba
baaababaa -> aaabababaaabbababaaabba
baaabaa -> aaabababaaabbababaaabbaabababaaabba
baaaa -> aaabababaaabbababaaabbaabababaaabbaabababaaabba

# < a,b | baaabababaababa=a >
baaabababaababa -> a
baaabababaabaa -> aaabababaababa
baaabababaaa -> aaabababaababaabababaababa
baaababaa -> aaabababaababaabababaabababababaababa
baaabaa -> aaabababaababaabababaabababababaababaabababaababa
baaaa -> aaabababaababaabababaabababababaababaabababaababaabababaababa

# < a,b | baaabababaabbba=a >
baaabababaabbba -> a
baaabababaabba -> aaabababaabbba
baaabababaaba -> aaabababaabba
baaabababaaa -> aaabababaaba
baaababaa -> aaabababaababababaabbba
baaabaa -> aaabababaababababaabbbaabababaabbba
baaaa -> aaabababaababababaabbbaabababaabbbaabababaabbba

# < a,b | baaababababaaba=a >
baaababababaaba -> a
baaababababaaa -> aaababababaaba
baaabababaa -> aaababababaabababababaaba
baaababaa -> aaababababaabababababaabaababababaaba
baaabaa -> aaababababaabababababaabaababababaabaababababaaba
baaaa -> aaababababaabababababaabaababababaabaababababaabaababababaaba

# < a,b | baaabababababba=a >
baaabababababba -> a
baaabababababa -> aaabababababba
baaababababaa -> aaabababababa
baaabababaa -> aaabababababaabababababba
baaababaa -> aaabababababaabababababbaabababababba
baaabaa -> aaabababababaabababababbaabababababbaabababababba
baaaa -> aaabababababaabababababbaabababababbaabababababbaabababababba

# < a,b | baaababababbaba=a >
baaababababbaba -> a
baaababababbaa -> aaababababbaba
baaababababa -> aaababababbabaababababbaba
baaabababaa -> aaababababbabaababababbaa
baaababaa -> aaababababbabaababababa
baaabaa -> aaababababbabaababababaababababbaba
baaaa -> aaababababbabaababababaababababbabaababababbaba

# < a,b | baaababababbbba=a >
baaababababbbba -> a
baaababababbba -> aaababababbbba
baaababababba -> aaababababbba
baaababababa -> aaababababba
baaabababaa -> aaababababa
baaababaa -> aaababababaababababbbba
baaabaa -> aaababababaababababbbbaababababbbba
baaaa -> aaababababaababababbbbaababababbbbaababababbbba

# < a,b | baaabababbaabba=a >
baaabababbaabba -> a
baaabababbaaba -> aaabababbaabba
baaabababbaaa -> aaabababbaaba
baaabababa -> aaabababbaababababbaabba
baaababaa -> aaabababbaababababbaaba
baaabaa -> aaabababbaababababbaabaabababbaabba
baaaa -> aaabababbaababababbaabaabababbaabbaabababbaabba

# < a,b | baaabababbababa=a >
baaabababbababa -> a
baaabababbabaa -> aaabababbababa
baaabababbaa -> aaabababbababaabababbababa
baaabababa -> aaabababbababaabababbababaabababbababa
baaababaa -> aaabababbababaabababbababaabababbabaa
baaabaa -> aaabababbababaabababbababaabababbaa
baaaa -> aaabababbababaabababbababaabababa

# < a,b | baaabababbabbba=a >
baaabababbabbba -> a
baaabababbabba -> aaabababbabbba
baaabababbaba -> aaabababbabba
baaabababbaa -> aaabababbaba
baaabababa -> aaabababbabaabababbabbba
baaababaa -> aaabababbabaabababbabba
baaabaa -> aaabababbabaabababbabbaabababbabbba
baaaa -> aaabababbabaabababbabbaabababbabbbaabababbabbba

# < a,b | baaabababbbabba=a >
baaabababbbabba -> a
baaabababbbaba -> aaabababbbabba
baaabababbbaa -> aaabababbbaba
baaabababba -> aaabababbbabaabababbbabba
baaabababa -> aaabababbbabaabababbbaba
baaababaa -> aaabababbbabaabababbbaa
baaabaa -> aaabababbbabaabababba
baaaa -> aaabababbbabaabababbaabababbbabba

# < a,b | baaabababbbbbba=a >
baaabababbbbbba -> a
baaabababbbbba -> aaabababbbbbba
baaabababbbba -> aaabababbbbba
baaabababbba -> aaabababbbba
baaabababba -> aaabababbba
baaabababa -> aaabababba
baaababaa -> aaabababa
baaabaa -> aaabababaabababbbbbba
baaaa -> aaabababaabababbbbbbaabababbbbbba

# < a,b | baaababbaaababa=a >
baaababbaaababa -> a
baaababbaaabaa -> aaababbaaababa
baaababbaaaa -> aaababbaaababaababbaaababa

# < a,b | baaababbaaabbba=a >
baaababbaaabbba -> a
baaababbaaabba -> aaababbaaabbba
baaababbaaaba -> aaababbaaabba
baaababa -> aaababbaaabbabbaaabbba
baaabaa -> aaababbaaabbabbaaabba
baaaa -> aaababbaaabbabbaaabbaababbaaabbba

# < a,b | baaababbaababba=a >
baaababbaababba -> a
baaababbaababa -> aaababbaababba
baaababbaabaa -> aaababbaababa
baaababbaaa -> aaababbaababaababbaababba
baaababa -> aaababbaababaababbaababbababbaababba
baaabaa -> aaababbaababaababbaababbababbaababa
baaaa -> aaababbaababaababbaababbababbaababaababbaababba

# < a,b | baaababbaabbaba=a >
baaababbaabbaba -> a
baaababbaabbaa -> aaababbaabbaba
baaababbaaba -> aaababbaabbabaababbaabbaba
baaababbaaa -> aaababbaabbabaababbaabbaa
baaababa -> aaababbaabbabaababbaabbaababbaabbaba
baaabaa -> aaababbaabbabaababbaabbaababbaabbaa
baaaa -> aaababbaabbabaababbaabbaababbaaba

# < a,b | baaababbaabbbba=a >
baaababbaabbbba -> a
baaababbaabbba -> aaababbaabbbba
baaababbaabba -> aaababbaabbba
baaababbaaba -> aaababbaabba
baaababbaaa -> aaababbaaba
baaababa -> aaababbaabababbaabbbba
baaabaa -> aaababbaabababbaabbba
baaaa -> aaababbaabababbaabbbaababbaabbbba

# < a,b | baaababbabaabba=a >
baaababbabaabba -> a
baaababbabaaba -> aaababbabaabba
baaababbabaaa -> aaababbabaaba
baaababbaa -> aaababbabaabababbabaabba
baaababa -> aaababbabaabababbabaabbaababbabaabba
baaabaa -> aaababbabaabababbabaabbaababbabaaba
baaaa -> aaababbabaabababbabaabbaababbabaabaababbabaabba

# < a,b | baaababbabababa=a >
baaababbabababa -> a
baaababbababaa -> aaababbabababa
baaababbabaa -> aaababbabababaababbabababa
baaababbaa -> aaababbabababaababbabababaababbabababa
baaababa -> aaababbabababaababbabababaababbabababaababbabababa
baaabaa -> aaababbabababaababbabababaababbabababaababbababaa
baaaa -> aaababbabababaababbabababaababbabababaababbabaa

# < a,b | baaababbababbba=a >
baaababbababbba -> a
baaababbababba -> aaababbababbba
baaababbababa -> aaababbababba
baaababbabaa -> aaababbababa
baaababbaa -> aaababbababaababbababbba
baaababa -> aaababbababaababbababbbaababbababbba
baaabaa -> aaababbababaababbababbbaababbababba
baaaa -> aaababbababaababbababbbaababbababbaababbababbba

# < a,b | baaababbabbabba=a >
baaababbabbabba -> a
baaababbabbaba -> aaababbabbabba
baaababbabbaa -> aaababbabbaba
baaababbaba -> aaababbabbabaababbabbabba
baaababbaa -> aaababbabbabaababbabbaba
baaababa -> aaababbabbabaababbabbabaababbabbabba
baaabaa -> aaababbabbabaababbabbabaababbabbaba
baaaa -> aaababbabbabaababbabbabaababbabbabaababbabbabba

# < a,b | baaababbabbbbba=a >
baaababbabbbbba -> a
baaababbabbbba -> aaababbabbbbba
baaababbabbba -> aaababbabbbba
baaababbabba -> aaababbabbba
baaababbaba -> aaababbabba
baaababbaa -> aaababbaba
baaababa -> aaababbabaababbabbbbba
baaabaa -> aaababbabaababbabbbba
baaaa -> aaababbabaababbabbbbaababbabbbbba

# < a,b | baaababbbaabbba=a >
baaababbbaabbba -> a
baaababbbaabba -> aaababbbaabbba
baaababbbaaba -> aaababbbaabba
baaababbbaaa -> aaababbbaaba
baaababba -> aaababbbaabababbbaabbba
baaababa -> aaababbbaabababbbaabba
baaabaa -> aaababbbaabababbbaaba
baaaa -> aaababbbaabababbbaabaababbbaabbba

# < a,b | baaababbbababba=a >
baaababbbababba -> a
baaababbbababa -> aaababbbababba
baaababbbabaa -> aaababbbababa
baaababbbaa -> aaababbbababaababbbababba
baaababba -> aaababbbababaababbbababbaababbbababba
baaababa -> aaababbbababaababbbababbaababbbababa
baaabaa -> aaababbbababaababbbababbaababbbabaa
baaaa -> aaababbbababaababbbababbaababbbaa

# < a,b | baaababbbabbbba=a >
baaababbbabbbba -> a
baaababbbabbba -> aaababbbabbbba
baaababbbabba -> aaababbbabbba
baaababbbaba -> aaababbbabba
baaababbbaa -> aaababbbaba
baaababba -> aaababbbabaababbbabbbba
baaababa -> aaababbbabaababbbabbba
baaabaa -> aaababbbabaababbbabba
baaaa -> aaababbbabaababbbabbaababbbabbbba

# < a,b | baaababbbbabbba=a >
baaababbbbabbba -> a
baaababbbbabba -> aaababbbbabbba
baaababbbbaba -> aaababbbbabba
baaababbbbaa -> aaababbbbaba
baaababbba -> aaababbbbabaababbbbabbba
baaababba -> aaababbbbabaababbbbabba
baaababa -> aaababbbbabaababbbbaba
baaabaa -> aaababbbbabaababbbbaa
baaaa -> aaababbbbabaababbba

# < a,b | baaababbbbbbbba=a >
baaababbbbbbbba -> a
baaababbbbbbba -> aaababbbbbbbba
baaababbbbbba -> aaababbbbbbba
baaababbbbba -> aaababbbbbba
baaababbbba -> aaababbbbba
baaababbba -> aaababbbba
baaababba -> aaababbba
baaababa -> aaababba
baaabaa -> aaababa
baaaa -> aaababaababbbbbbbba

# < a,b | baaabbaaaaababa=a >
baaabbaaaaababa -> a
baaabbaaaaabaa -> aaabbaaaaababa
baaabbaaaaaa -> aaabbaaaaababaabbaaaaababa

# < a,b | baaabbaaaaabbaa=a >
baaabbaaaaabbaa -> a
baaabbaaaaaba -> aabbaaaaabbaa
baaabbaaaaaa -> aabbaaaaabbaaaabbaaaaabbaa

# < a,b | baaabbaaaabaaba=a >
baaabbaaaabaaba -> a
baaabbaaaabaaa -> aaabbaaaabaaba
baaabbaaaaa -> aaabbaaaabaababbaaaabaaba

# < a,b | baaabbaaaababba=a >
baaabbaaaababba -> a
baaabbaaaababa -> aaabbaaaababba
baaabbaaaabaa -> aaabbaaaababa
baaabbaaaaa -> aaabbaaaababaabbaaaababba

# < a,b | baaabbaaaabbaaa=a >
baaabbaaaabbaaa -> a
baaabbaaaaba -> abbaaaabbaaa
baaabbaaaaa -> abbaaaabbaaaaabbaaaabbaaa

# < a,b | baaabbaaaabbaba=a >
baaabbaaaabbaba -> a
baaabbaaaabbaa -> aaabbaaaabbaba
baaabbaaaaba -> aaabbaaaabbabaabbaaaabbaba
baaabbaaaaa -> aaabbaaaabbabaabbaaaabbaa

# < a,b | baaabbaaaabbbaa=a >
baaabbaaaabbbaa -> a
baaabbaaaabba -> aabbaaaabbbaa
baaabbaaaaba -> aabbaaaabbbaaaabbaaaabbbaa
baaabbaaaaa -> aabbaaaabbbaaaabbaaaabbbaaaabbaaaabbbaa

# < a,b | baaabbaaabaabaa=a >
baaabbaaabaabaa -> a
baaabbaaabaaa -> aabbaaabaabaa
baaabbaaaa -> aabbaaabaabaabbaaabaabaa

# < a,b | baaabbaaabaabba=a >
baaabbaaabaabba -> a
baaabbaaabaaba -> aaabbaaabaabba
baaabbaaabaaa -> aaabbaaabaaba
baaabbaaaa -> aaabbaaabaababbaaabaabba

# < a,b | baaabbaaababaaa=a >
baaabbaaababaaa -> a
baaabbaaabaa -> abbaaababaaa
baaabbaaaa -> abbaaababaaaabbaaababaaa

# < a,b | baaabbaaabababa=a >
baaabbaaabababa -> a
baaabbaaababaa -> aaabbaaabababa
baaabbaaabaa -> aaabbaaabababaabbaaabababa
baaabbaaaa -> aaabbaaabababaabbaaabababaabbaaabababa

# < a,b | baaabbaaababbaa=a >
baaabbaaababbaa -> a
baaabbaaababa -> aabbaaababbaa
baaabbaaabaa -> aabbaaababbaaaabbaaababbaa
baaabbaaaa -> aabbaaababbaaaabbaaababa

# < a,b | baaabbaaababbba=a >
baaabbaaababbba -> a
baaabbaaababba -> aaabbaaababbba
baaabbaaababa -> aaabbaaababba
baaabbaaabaa -> aaabbaaababa
baaabbaaaa -> aaabbaaababaabbaaababbba

# < a,b | baaabbaaabbaaba=a >
baaabbaaabbaaba -> a
baaabbaaabbaaa -> aaabbaaabbaaba
baaaba -> aaabbaaabbaababbaaba
baaaa -> aaabbaaabbaababbaaa

# < a,b | baaabbaaabbabba=a >
baaabbaaabbabba -> a
baaabbaaabbaba -> aaabbaaabbabba
baaabbaaabbaa -> aaabbaaabbaba
baaaba -> aaabbaaabbabaabbabba
baaaa -> aaabbaaabbabaabbaba

# < a,b | baaabbaaabbbaba=a >
baaabbaaabbbaba -> a
baaabbaaabbbaa -> aaabbaaabbbaba
baaabbaaabba -> aaabbaaabbbabaabbaaabbbaba
baaaba -> aaabbaaabbbabaabbaaabbbabaaabbbaba
baaaa -> aaabbaaabbbabaabbaaabbbabaaabbbaa

# < a,b | baaabbaaabbbbba=a >
baaabbaaabbbbba -> a
baaabbaaabbbba -> aaabbaaabbbbba
baaabbaaabbba -> aaabbaaabbbba
baaabbaaabba -> aaabbaaabbba
baaaba -> aaabbaaabbbaaabbbbba
baaaa -> aaabbaaabbbaaabbbba

# < a,b | baaabbaabaababa=a >
baaabbaabaababa -> a
baaabbaabaabaa -> aaabbaabaababa
baaabbaabaaa -> aaabbaabaababaabbaabaababa
baaabbaaa -> aaabbaabaababaabbaabaabababbaabaababa
baaaba -> aaabbaabaababaabbaabaabababbaabaabababbaabaababa
baaaa -> aaabbaabaababaabbaabaabababbaabaabababbaabaabaa

# < a,b | baaabbaabaabbba=a >
baaabbaabaabbba -> a
baaabbaabaabba -> aaabbaabaabbba
baaabbaabaaba -> aaabbaabaabba
baaabbaabaaa -> aaabbaabaaba
baaabbaaa -> aaabbaabaababbaabaabbba
baaaba -> aaabbaabaababbaabaabbbabbaabaabbba
baaaa -> aaabbaabaababbaabaabbbabbaabaabba

# < a,b | baaabbaababaaba=a >
baaabbaababaaba -> a
baaabbaababaaa -> aaabbaababaaba
baaabbaabaa -> aaabbaababaababbaababaaba
baaabbaaa -> aaabbaababaababbaababaabaabbaababaaba
baaaba -> aaabbaababaababbaababaabaabbaababaababbaababaaba
baaaa -> aaabbaababaababbaababaabaabbaababaababbaababaaa

# < a,b | baaabbaabababba=a >
baaabbaabababba -> a
baaabbaabababa -> aaabbaabababba
baaabbaababaa -> aaabbaabababa
baaabbaabaa -> aaabbaabababaabbaabababba
baaabbaaa -> aaabbaabababaabbaabababbaabbaabababba
baaaba -> aaabbaabababaabbaabababbaabbaabababbabbaabababba
baaaa -> aaabbaabababaabbaabababbaabbaabababbabbaabababa

# < a,b | baaabbaababbaba=a >
baaabbaababbaba -> a
baaabbaababbaa -> aaabbaababbaba
baaabbaababa -> aaabbaababbabaabbaababbaba
baaabbaabaa -> aaabbaababbabaabbaababbaa
baaabbaaa -> aaabbaababbabaabbaababa
baaaba -> aaabbaababbabaabbaabababbaababbaba
baaaa -> aaabbaababbabaabbaabababbaababbaa

# < a,b | baaabbaababbbba=a >
baaabbaababbbba -> a
baaabbaababbba -> aaabbaababbbba
baaabbaababba -> aaabbaababbba
baaabbaababa -> aaabbaababba
baaabbaabaa -> aaabbaababa
baaabbaaa -> aaabbaababaabbaababbbba
baaaba -> aaabbaababaabbaababbbbabbaababbbba
baaaa -> aaabbaababaabbaababbbbabbaababbba

# < a,b | baaabbaabbaabba=a >
baaabbaabbaabba -> a
baaabbaabbaaba -> aaabbaabbaabba
baaabbaabbaaa -> aaabbaabbaaba
baaabbaaba -> aaabbaabbaababbaabbaabba
baaabbaaa -> aaabbaabbaababbaabbaaba
baaaba -> aaabbaabbaababbaabbaababbaabbaabba
baaaa -> aaabbaabbaababbaabbaababbaabbaaba

# < a,b | baaabbaabbababa=a >
baaabbaabbababa -> a
baaabbaabbabaa -> aaabbaabbababa
baaabbaabbaa -> aaabbaabbababaabbaabbababa
baaabbaaba -> aaabbaabbababaabbaabbababaabbaabbababa
baaabbaaa -> aaabbaabbababaabbaabbababaabbaabbabaa
baaaba -> aaabbaabbababaabbaabbababaabbaabbabaabbaabbababa
baaaa -> aaabbaabbababaabbaabbababaabbaabbabaabbaabbabaa

# < a,b | baaabbaabbabbba=a >
baaabbaabbabbba -> a
baaabbaabbabba -> aaabbaabbabbba
baaabbaabbaba -> aaabbaabbabba
baaabbaabbaa -> aaabbaabbaba
baaabbaaba -> aaabbaabbabaabbaabbabbba
baaabbaaa -> aaabbaabbabaabbaabbabba
baaaba -> aaabbaabbabaabbaabbabbabbaabbabbba
baaaa -> aaabbaabbabaabbaabbabbabbaabbabba

# < a,b | baaabbaabbbabba=a >
baaabbaabbbabba -> a
baaabbaabbbaba -> aaabbaabbbabba
baaabbaabbbaa -> aaabbaabbbaba
baaabbaabba -> aaabbaabbbabaabbaabbbabba
baaabbaaba -> aaabbaabbbabaabbaabbbaba
baaabbaaa -> aaabbaabbbabaabbaabbbaa
baaaba -> aaabbaabbbabaabbaabbbaabbaabbbabba
baaaa -> aaabbaabbbabaabbaabbbaabbaabbbaba

# < a,b | baaabbaabbbbbba=a >
baaabbaabbbbbba -> a
baaabbaabbbbba -> aaabbaabbbbbba
baaabbaabbbba -> aaabbaabbbbba
baaabbaabbba -> aaabbaabbbba
baaabbaabba -> aaabbaabbba
baaabbaaba -> aaabbaabba
baaabbaaa -> aaabbaaba
baaaba -> aaabbaababbaabbbbbba
baaaa -> aaabbaababbaabbbbba

# < a,b | baaabbabaaababa=a >
baaabbabaaababa -> a
baaabbabaaabaa -> aaabbabaaababa
baaabbabaaaa -> aaabbabaaababaabbabaaababa

# < a,b | baaabbabaaabbaa=a >
baaabbabaaabbaa -> a
baaabbabaaaba -> aabbabaaabbaa
baaabbabaaaa -> aabbabaaabbaaaabbabaaabbaa

# < a,b | baaabbabaaabbba=a >
baaabbabaaabbba -> a
baaabbabaaabba -> aaabbabaaabbba
baaabbaa -> aaabbabaaabbbabaaabbba
baaaba -> aaabbabaaabbbabaaabbbaabbabaaabbba
baaaa -> aaabbabaaabbbabaaabbbaabbabaaabba

# < a,b | baaabbabaabaaba=a >
baaabbabaabaaba -> a
baaabbabaabaaa -> aaabbabaabaaba
baaabbabaaa -> aaabbabaabaababbabaabaaba
baaabbaa -> aaabbabaabaababbabaabaababbabaabaaba
baaaba -> aaabbabaabaababbabaabaababbabaabaabaabbabaabaaba
baaaa -> aaabbabaabaababbabaabaababbabaabaabaabbabaabaaa

# < a,b | baaabbabaababba=a >
baaabbabaababba -> a
baaabbabaababa -> aaabbabaababba
baaabbabaabaa -> aaabbabaababa
baaabbabaaa -> aaabbabaababaabbabaababba
baaabbaa -> aaabbabaababaabbabaababbabbabaababba
baaaba -> aaabbabaababaabbabaababbabbabaababbaabbabaababba
baaaa -> aaabbabaababaabbabaababbabbabaababbaabbabaababa

# < a,b | baaabbabaabbaba=a >
baaabbabaabbaba -> a
baaabbabaabbaa -> aaabbabaabbaba
baaabbabaaba -> aaabbabaabbabaabbabaabbaba
baaabbabaaa -> aaabbabaabbabaabbabaabbaa
baaabbaa -> aaabbabaabbabaabbabaabbaabbabaabbaba
baaaba -> aaabbabaabbabaabbabaabbaabbabaabbabaabbabaabbaba
baaaa -> aaabbabaabbabaabbabaabbaabbabaabbabaabbabaabbaa

# < a,b | baaabbabaabbbba=a >
baaabbabaabbbba -> a
baaabbabaabbba -> aaabbabaabbbba
baaabbabaabba -> aaabbabaabbba
baaabbabaaba -> aaabbabaabba
baaabbabaaa -> aaabbabaaba
baaabbaa -> aaabbabaababbabaabbbba
baaaba -> aaabbabaababbabaabbbbaabbabaabbbba
baaaa -> aaabbabaababbabaabbbbaabbabaabbba

# < a,b | baaabbababaabba=a >
baaabbababaabba -> a
baaabbababaaba -> aaabbababaabba
baaabbababaaa -> aaabbababaaba
baaabbabaa -> aaabbababaababbababaabba
baaabbaa -> aaabbababaababbababaabbaabbababaabba
baaaba -> aaabbababaababbababaabbaabbababaabbaabbababaabba
baaaa -> aaabbababaababbababaabbaabbababaabbaabbababaaba

# < a,b | baaabbababababa=a >
baaabbababababa -> a
baaabbabababaa -> aaabbababababa
baaabbababaa -> aaabbababababaabbababababa
baaabbabaa -> aaabbababababaabbababababaabbababababa
baaabbaa -> aaabbababababaabbababababaabbababababaabbababababa
baaaba -> aaabbababababaabbababababaabbababababaabbababababaabbababababa
baaaa -> aaabbababababaabbababababaabbababababaabbababababaabbabababaa

# < a,b | baaabbabababbba=a >
baaabbabababbba -> a
baaabbabababba -> aaabbabababbba
baaabbabababa -> aaabbabababba
baaabbababaa -> aaabbabababa
baaabbabaa -> aaabbabababaabbabababbba
baaabbaa -> aaabbabababaabbabababbbaabbabababbba
baaaba -> aaabbabababaabbabababbbaabbabababbbaabbabababbba
baaaa -> aaabbabababaabbabababbbaabbabababbbaabbabababba

# < a,b | baaabbababbabba=a >
baaabbababbabba -> a
baaabbababbaba -> aaabbababbabba
baaabbababbaa -> aaabbababbaba
baaabbababa -> aaabbababbabaabbababbabba
baaabbabaa -> aaabbababbabaabbababbaba
baaabbaa -> aaabbababbabaabbababbabaabbababbabba
baaaba -> aaabbababbabaabbababbabaabbababbabbaabbababbabba
baaaa -> aaabbababbabaabbababbabaabbababbabbaabbababbaba

# < a,b | baaabbababbbbba=a >
baaabbababbbbba -> a
baaabbababbbba -> aaabbababbbbba
baaabbababbba -> aaabbababbbba
baaabbababba -> aaabbababbba
baaabbababa -> aaabbababba
baaabbabaa -> aaabbababa
baaabbaa -> aaabbababaabbababbbbba
baaaba -> aaabbababaabbababbbbbaabbababbbbba
baaaa -> aaabbababaabbababbbbbaabbababbbba

# < a,b | baaabbabbaabbba=a >
baaabbabbaabbba -> a
baaabbabbaabba -> aaabbabbaabbba
baaabbabbaaba -> aaabbabbaabba
baaabbabbaaa -> aaabbabbaaba
baaabbaba -> aaabbabbaababbabbaabbba
baaabbaa -> aaabbabbaababbabbaabba
baaaba -> aaabbabbaababbabbaabbaabbabbaabbba
baaaa -> aaabbabbaababbabbaabbaabbabbaabba

# < a,b | baaabbabbababba=a >
baaabbabbababba -> a
baaabbabbababa -> aaabbabbababba
baaabbabbabaa -> aaabbabbababa
baaabbabbaa -> aaabbabbababaabbabbababba
baaabbaba -> aaabbabbababaabbabbababbaabbabbababba
baaabbaa -> aaabbabbababaabbabbababbaabbabbababa
baaaba -> aaabbabbababaabbabbababbaabbabbababaabbabbababba
baaaa -> aaabbabbababaabbabbababbaabbabbababaabbabbababa

# < a,b | baaabbabbabbaba=a >
baaabbabbabbaba -> a
baaabbabbabbaa -> aaabbabbabbaba
baaabbabbaba -> aaabbabbabbabaabbabbabbaba
baaabbabbaa -> aaabbabbabbabaabbabbabbaa
baaabbaba -> aaabbabbabbabaabbabbaba
baaabbaa -> aaabbabbabbabaabbabbaa
baaaba -> aaabbabbabbabaabbaba
baaaa -> aaabbabbabbabaabbaa

# < a,b | baaabbabbabbbba=a >
baaabbabbabbbba -> a
baaabbabbabbba -> aaabbabbabbbba
baaabbabbabba -> aaabbabbabbba
baaabbabbaba -> aaabbabbabba
baaabbabbaa -> aaabbabbaba
baaabbaba -> aaabbabbabaabbabbabbbba
baaabbaa -> aaabbabbabaabbabbabbba
baaaba -> aaabbabbabaabbabbabbbaabbabbabbbba
baaaa -> aaabbabbabaabbabbabbbaabbabbabbba

# < a,b | baaabbabbbabbba=a >
baaabbabbbabbba -> a
baaabbabbbabba -> aaabbabbbabbba
baaabbabbbaba -> aaabbabbbabba
baaabbabbbaa -> aaabbabbbaba
baaabbabba -> aaabbabbbabaabbabbbabbba
baaabbaba -> aaabbabbbabaabbabbbabba
baaabbaa -> aaabbabbbabaabbabbbaba
baaaba -> aaabbabbbabaabbabbbabaabbabbbabbba
baaaa -> aaabbabbbabaabbabbbabaabbabbbabba

# < a,b | baaabbabbbbbbba=a >
baaabbabbbbbbba -> a
baaabbabbbbbba -> aaabbabbbbbbba
baaabbabbbbba -> aaabbabbbbbba
baaabbabbbba -> aaabbabbbbba
baaabbabbba -> aaabbabbbba
baaabbabba -> aaabbabbba
baaabbaba -> aaabbabba
baaabbaa -> aaabbaba
baaaba -> aaabbabaabbabbbbbbba
baaaa -> aaabbabaabbabbbbbba

# < a,b | baaabbbaaaababa=a >
baaabbbaaaababa -> a
baaabbbaaaabaa -> aaabbbaaaababa
baaabbbaaaaa -> aaabbbaaaababaabbbaaaababa

# < a,b | baaabbbaaaabbaa=a >
baaabbbaaaabbaa -> a
baaabbbaaaaba -> aabbbaaaabbaa
baaabbbaaaaa -> aabbbaaaabbaaaabbbaaaabbaa

# < a,b | baaabbbaaabaaba=a >
baaabbbaaabaaba -> a
baaabbbaaabaaa -> aaabbbaaabaaba
baaabbbaaaa -> aaabbbaaabaababbbaaabaaba

# < a,b | baaabbbaaababba=a >
baaabbbaaababba -> a
baaabbbaaababa -> aaabbbaaababba
baaabbbaaabaa -> aaabbbaaababa
baaabbbaaaa -> aaabbbaaababaabbbaaababba

# < a,b | baaabbbaaabbaaa=a >
baaabbbaaabbaaa -> a
baaabbbaaaba -> abbbaaabbaaa
baaabbbaaaa -> abbbaaabbaaaaabbbaaabbaaa

# < a,b | baaabbbaaabbaba=a >
baaabbbaaabbaba -> a
baaabbbaaabbaa -> aaabbbaaabbaba
baaabbbaaaba -> aaabbbaaabbabaabbbaaabbaba
baaabbbaaaa -> aaabbbaaabbabaabbbaaabbaa

# < a,b | baaabbbaaabbbba=a >
baaabbbaaabbbba -> a
baaabbbaaabbba -> aaabbbaaabbbba
baaabba -> aaabbbaaabbbbaaabbbba
baaaba -> aaabbbaaabbbbaaabbba
baaaa -> aaabaaabbbbaaabbbba

# < a,b | baaabbbaabaabba=a >
baaabbbaabaabba -> a
baaabbbaabaaba -> aaabbbaabaabba
baaabbbaabaaa -> aaabbbaabaaba
baaabbbaaa -> aaabbbaabaababbbaabaabba
baaabba -> aaabbbaabaababbbaabaabbabbbaabaabba
baaaba -> aaabbbaabaababbbaabaabbabbbaabaaba
baaaa -> aaabbbaabaababbbaabaabbabbbaabaaa

# < a,b | baaabbbaababbba=a >
baaabbbaababbba -> a
baaabbbaababba -> aaabbbaababbba
baaabbbaababa -> aaabbbaababba
baaabbbaabaa -> aaabbbaababa
baaabbbaaa -> aaabbbaababaabbbaababbba
baaabba -> aaabbbaababaabbbaababbbabbbaababbba
baaaba -> aaabbbaababaabbbaababbbabbbaababba
baaaa -> aaabbbaababaabbbaababbbabbbaababa

# < a,b | baaabbbaabbabba=a >
baaabbbaabbabba -> a
baaabbbaabbaba -> aaabbbaabbabba
baaabbbaabbaa -> aaabbbaabbaba
baaabbbaaba -> aaabbbaabbabaabbbaabbabba
baaabbbaaa -> aaabbbaabbabaabbbaabbaba
baaabba -> aaabbbaabbabaabbbaabbababbbaabbabba
baaaba -> aaabbbaabbabaabbbaabbababbbaabbaba
baaaa -> aaabbbaabbabaabbbaabbababbbaabbaa

# < a,b | baaabbbaabbbbba=a >
baaabbbaabbbbba -> a
baaabbbaabbbba -> aaabbbaabbbbba
baaabbbaabbba -> aaabbbaabbbba
baaabbbaabba -> aaabbbaabbba
baaabbbaaba -> aaabbbaabba
baaabbbaaa -> aaabbbaaba
baaabba -> aaabbbaababbbaabbbbba
baaaba -> aaabbbaababbbaabbbba
baaaa -> aaabbbaababbbaabbba

# < a,b | baaabbbabaabbba=a >
baaabbbabaabbba -> a
baaabbbabaabba -> aaabbbabaabbba
baaabbbabaaba -> aaabbbabaabba
baaabbbabaaa -> aaabbbabaaba
baaabbbaa -> aaabbbabaababbbabaabbba
baaabba -> aaabbbabaababbbabaabbbaabbbabaabbba
baaaba -> aaabbbabaababbbabaabbbaabbbabaabba
baaaa -> aaabbbabaababbbabaabbbaabbbabaaba

# < a,b | baaabbbabababba=a >
baaabbbabababba -> a
baaabbbabababa -> aaabbbabababba
baaabbbababaa -> aaabbbabababa
baaabbbabaa -> aaabbbabababaabbbabababba
baaabbbaa -> aaabbbabababaabbbabababbaabbbabababba
baaabba -> aaabbbabababaabbbabababbaabbbabababbaabbbabababba
baaaba -> aaabbbabababaabbbabababbaabbbabababbaabbbabababa
baaaa -> aaabbbabababaabbbabababbaabbbabababbaabbbababaa

# < a,b | baaabbbababbbba=a >
baaabbbababbbba -> a
baaabbbababbba -> aaabbbababbbba
baaabbbababba -> aaabbbababbba
baaabbbababa -> aaabbbababba
baaabbbabaa -> aaabbbababa
baaabbbaa -> aaabbbababaabbbababbbba
baaabba -> aaabbbababaabbbababbbbaabbbababbbba
baaaba -> aaabbbababaabbbababbbbaabbbababbba
baaaa -> aaabbbababaabbbababbbbaabbbababba

# < a,b | baaabbbabbaabba=a >
baaabbbabbaabba -> a
baaabbbabbaaba -> aaabbbabbaabba
baaabbbabbaaa -> aaabbbabbaaba
baaabbbaba -> aaabbbabbaababbbabbaabba
baaabbbaa -> aaabbbabbaababbbabbaaba
baaabba -> aaabbbabbaababbbabbaabaabbbabbaabba
baaaba -> aaabbbabbaababbbabbaabaabbbabbaaba
baaaa -> aaabbbabbaababbbabbaabaabbbabbaaa

# < a,b | baaabbbabbabbba=a >
baaabbbabbabbba -> a
baaabbbabbabba -> aaabbbabbabbba
baaabbbabbaba -> aaabbbabbabba
baaabbbabbaa -> aaabbbabbaba
baaabbbaba -> aaabbbabbabaabbbabbabbba
baaabbbaa -> aaabbbabbabaabbbabbabba
baaabba -> aaabbbabbabaabbbabbabbaabbbabbabbba
baaaba -> aaabbbabbabaabbbabbabbaabbbabbabba
baaaa -> aaabbbabbabaabbbabbabbaabbbabbaba

# < a,b | baaabbbabbbabba=a >
baaabbbabbbabba -> a
baaabbbabbbaba -> aaabbbabbbabba
baaabbbabbbaa -> aaabbbabbbaba
baaabbbabba -> aaabbbabbbabaabbbabbbabba
baaabbbaba -> aaabbbabbbabaabbbabbbaba
baaabbbaa -> aaabbbabbbabaabbbabbbaa
baaabba -> aaabbbabbbabaabbbabba
baaaba -> aaabbbabbbabaabbbaba
baaaa -> aaabbbabbbabaabbbaa

# < a,b | baaabbbabbbbbba=a >
baaabbbabbbbbba -> a
baaabbbabbbbba -> aaabbbabbbbbba
baaabbbabbbba -> aaabbbabbbbba
baaabbbabbba -> aaabbbabbbba
baaabbbabba -> aaabbbabbba
baaabbbaba -> aaabbbabba
baaabbbaa -> aaabbbaba
baaabba -> aaabbbabaabbbabbbbbba
baaaba -> aaabbbabaabbbabbbbba
baaaa -> aaabbbabaabbbabbbba

# < a,b | baaabbbbaaababa=a >
baaabbbbaaababa -> a
baaabbbbaaabaa -> aaabbbbaaababa
baaabbbbaaaa -> aaabbbbaaababaabbbbaaababa

# < a,b | baaabbbbaaabbaa=a >
baaabbbbaaabbaa -> a
baaabbbbaaaba -> aabbbbaaabbaa
baaabbbbaaaa -> aabbbbaaabbaaaabbbbaaabbaa

# < a,b | baaabbbbaabbbba=a >
baaabbbbaabbbba -> a
baaabbbbaabbba -> aaabbbbaabbbba
baaabbbbaabba -> aaabbbbaabbba
baaabbbbaaba -> aaabbbbaabba
baaabbbbaaa -> aaabbbbaaba
baaabbba -> aaabbbbaababbbbaabbbba
baaabba -> aaabbbbaababbbbaabbba
baaaba -> aaabbbbaababbbbaabba
baaaa -> aaabbbbaababbbbaaba

# < a,b | baaabbbbababbba=a >
baaabbbbababbba -> a
baaabbbbababba -> aaabbbbababbba
baaabbbbababa -> aaabbbbababba
baaabbbbabaa -> aaabbbbababa
baaabbbbaa -> aaabbbbababaabbbbababbba
baaabbba -> aaabbbbababaabbbbababbbaabbbbababbba
baaabba -> aaabbbbababaabbbbababbbaabbbbababba
baaaba -> aaabbbbababaabbbbababbbaabbbbababa
baaaa -> aaabbbbababaabbbbababbbaabbbbabaa

# < a,b | baaabbbbabbbbba=a >
baaabbbbabbbbba -> a
baaabbbbabbbba -> aaabbbbabbbbba
baaabbbbabbba -> aaabbbbabbbba
baaabbbbabba -> aaabbbbabbba
baaabbbbaba -> aaabbbbabba
baaabbbbaa -> aaabbbbaba
baaabbba -> aaabbbbabaabbbbabbbbba
baaabba -> aaabbbbabaabbbbabbbba
baaaba -> aaabbbbabaabbbbabbba
baaaa -> aaabbbbabaabbbbabba

# < a,b | baaabbbbbabbbba=a >
baaabbbbbabbbba -> a
baaabbbbbabbba -> aaabbbbbabbbba
baaabbbbbabba -> aaabbbbbabbba
baaabbbbbaba -> aaabbbbbabba
baaabbbbbaa -> aaabbbbbaba
baaabbbba -> aaabbbbbabaabbbbbabbbba
baaabbba -> aaabbbbbabaabbbbbabbba
baaabba -> aaabbbbbabaabbbbbabba
baaaba -> aaabbbbbabaabbbbbaba
baaaa -> aaabbbbbabaabbbbbaa

# < a,b | baabaaaaaaababa=a >
baabaaaaaaababa -> a
baabaaaaaaabaa -> aabaaaaaaababa
baabaaaaaaaa -> aabaaaaaaabababaaaaaaababa

# < a,b | baabaaaaaaabbaa=a >
baabaaaaaaabbaa -> a
baabaaaaaaaba -> abaaaaaaabbaa
baabaaaaaaaa -> abaaaaaaabbaaabaaaaaaabbaa

# < a,b | baabaaaaaababba=a >
baabaaaaaababba -> a
baabaaaaaababa -> aabaaaaaababba
baabaaaaaabaa -> aabaaaaaababa
baabaaaaaaa -> aabaaaaaabababaaaaaababba

# < a,b | baabaaaaaabbaba=a >
baabaaaaaabbaba -> a
baabaaaaaabbaa -> aabaaaaaabbaba
baabaaaaaaba -> aabaaaaaabbababaaaaaabbaba
baabaaaaaaa -> aabaaaaaabbababaaaaaabbaa

# < a,b | baabaaaaaabbbaa=a >
baabaaaaaabbbaa -> a
baabaaaaaabba -> abaaaaaabbbaa
baabaaaaaaba -> abaaaaaabbbaaabaaaaaabbbaa
baabaaaaaaa -> abaaaaaabbbaaabaaaaaabbbaaabaaaaaabbbaa

# < a,b | baabaaaaabaabba=a >
baabaaaaabaabba -> a
baabaaaaabaaba -> aabaaaaabaabba
baabaaaaabaaa -> aabaaaaabaaba
baabaaaaaa -> aabaaaaabaabbaaaaabaabba

# < a,b | baabaaaaabababa=a >
baabaaaaabababa -> a
baabaaaaababaa -> aabaaaaabababa
baabaaaaabaa -> aabaaaaababababaaaaabababa
baabaaaaaa -> aabaaaaababababaaaaababababaaaaabababa

# < a,b | baabaaaaababbaa=a >
baabaaaaababbaa -> a
baabaaaaababa -> abaaaaababbaa
baabaaaaabaa -> abaaaaababbaaabaaaaababbaa
baabaaaaaa -> abaaaaababbaaabaaaaababa

# < a,b | baabaaaaababbba=a >
baabaaaaababbba -> a
baabaaaaababba -> aabaaaaababbba
baabaaaaababa -> aabaaaaababba
baabaaaaabaa -> aabaaaaababa
baabaaaaaa -> aabaaaaabababaaaaababbba

# < a,b | baabaaaaabbabaa=a >
baabaaaaabbabaa -> a
baabaaaaabbaa -> abaaaaabbabaa
baabaaaaaba -> abaaaaabbaa
baabaaaaaa -> abaaaaabbaaabaaaaabbabaa

# < a,b | baabaaaaabbabba=a >
baabaaaaabbabba -> a
baabaaaaabbaba -> aabaaaaabbabba
baabaaaaabbaa -> aabaaaaabbaba
baabaaaaaba -> aabaaaaabbababaaaaabbabba
baabaaaaaa -> aabaaaaabbababaaaaabbaba

# < a,b | baabaaaaabbbaba=a >
baabaaaaabbbaba -> a
baabaaaaabbbaa -> aabaaaaabbbaba
baabaaaaabba -> aabaaaaabbbababaaaaabbbaba
baabaaaaaba -> aabaaaaabbbababaaaaabbbaa
baabaaaaaa -> aabaaaaabbbababaaaaabbbaaabaaaaabbbaba

# < a,b | baabaaaaabbbbaa=a >
baabaaaaabbbbaa -> a
baabaaaaabbba -> abaaaaabbbbaa
baabaaaaabba -> abaaaaabbbbaaabaaaaabbbbaa
baabaaaaaba -> abaaaaabbbbaaabaaaaabbbbaaabaaaaabbbbaa
baabaaaaaa -> abaaaaabbbbaaabaaaaabbbbaaabaaaaabbbbaaabaaaaabbbbaa

# < a,b | baabaaaabaababa=a >
baabaaaabaababa -> a
baabaaaabaabaa -> aabaaaabaababa
baabaaaabaaa -> aabaaaabaabababaaaabaababa
baabaaaaa -> aabaaaabaababaaabaababa

# < a,b | baabaaaabaabbaa=a >
baabaaaabaabbaa -> a
baabaaaabaaba -> abaaaabaabbaa
baabaaaabaaa -> abaaaabaabbaaabaaaabaabbaa
baabaaaaa -> abaaaabaabbaaaaabaabbaa

# < a,b | baabaaaabaabbba=a >
baabaaaabaabbba -> a
baabaaaabaabba -> aabaaaabaabbba
baabaaaabaaba -> aabaaaabaabba
baabaaaabaaa -> aabaaaabaaba
baabaaaaa -> aabaaaabaabbaaaabaabbba

# < a,b | baabaaaababaaba=a >
baabaaaababaaba -> a
baabaaaababaaa -> aabaaaababaaba
baabaaaabaa -> aaaababaaba
baabaaaaa -> aaaababaababaaaababaaba

# < a,b | baabaaaabababba=a >
baabaaaabababba -> a
baabaaaabababa -> aabaaaabababba
baabaaaababaa -> aabaaaabababa
baabaaaabaa -> aabaaaababababaaaabababba
baabaaaaa -> aabaaaababababaaaabababbabaaaabababba

# < a,b | baabaaaababbaba=a >
baabaaaababbaba -> a
baabaaaababbaa -> aabaaaababbaba
baabaaaababa -> aabaaaababbababaaaababbaba
baabaaaabaa -> aabaaaababbababaaaababbaa
baabaaaaa -> aabaaaababbababaaaababa

# < a,b | baabaaaababbbaa=a >
baabaaaababbbaa -> a
baabaaaababba -> abaaaababbbaa
baabaaaababa -> abaaaababbbaaabaaaababbbaa
baabaaaabaa -> abaaaababbbaaabaaaababbbaaabaaaababbbaa
baabaaaaa -> abaaaababbbaaabaaaababbbaaabaaaababba

# < a,b | baabaaaababbbba=a >
baabaaaababbbba -> a
baabaaaababbba -> aabaaaababbbba
baabaaaababba -> aabaaaababbba
baabaaaababa -> aabaaaababba
baabaaaabaa -> aabaaaababa
baabaaaaa -> aabaaaabababaaaababbbba

# < a,b | baabaaaabbaabaa=a >
baabaaaabbaabaa -> a
baabaaaabbaaa -> abaaaabbaabaa
baabaaaaba -> aaabbaabaa
baabaaaaa -> aaabbaabaaabaaaabbaabaa

# < a,b | baabaaaabbaabba=a >
baabaaaabbaabba -> a
baabaaaabbaaba -> aabaaaabbaabba
baabaaaabbaaa -> aabaaaabbaaba
baabaaaaba -> aabaaaabbaabbaaaabbaabba
baabaaaaa -> aabaaaabbaabbaaaabbaaba

# < a,b | baabaaaabbababa=a >
baabaaaabbababa -> a
baabaaaabbabaa -> aabaaaabbababa
baabaaaabbaa -> aabaaaabbabababaaaabbababa
baabaaaaba -> aabaaaabbabababaaaabbabababaaaabbababa
baabaaaaa -> aabaaaabbabababaaaabbabababaaaabbabaa

# < a,b | baabaaaabbabbaa=a >
baabaaaabbabbaa -> a
baabaaaabbaba -> abaaaabbabbaa
baabaaaabbaa -> abaaaabbabbaaabaaaabbabbaa
baabaaaaba -> abaaaabbabbaaabaaaabbaba
baabaaaaa -> abaaaabbabbaaabaaaabbaa

# < a,b | baabaaaabbabbba=a >
baabaaaabbabbba -> a
baabaaaabbabba -> aabaaaabbabbba
baabaaaabbaba -> aabaaaabbabba
baabaaaabbaa -> aabaaaabbaba
baabaaaaba -> aabaaaabbababaaaabbabbba
baabaaaaa -> aabaaaabbababaaaabbabba

# < a,b | baabaaaabbbaaba=a >
baabaaaabbbaaba -> a
baabaaaabbbaaa -> aabaaaabbbaaba
baabaaaabba -> aaaabbbaaba
baabaaaaba -> aaaabbbaaa
baabaaaaa -> aaaabbbaaaabaaaabbbaaba

# < a,b | baabaaaabbbabaa=a >
baabaaaabbbabaa -> a
baabaaaabbbaa -> abaaaabbbabaa
baabaaaabba -> abaaaabbbaa
baabaaaaba -> abaaaabbbaaabaaaabbbabaa
baabaaaaa -> abaaaabbbaaabaaaabbbabaaabaaaabbbabaa

# < a,b | baabaaaabbbabba=a >
baabaaaabbbabba -> a
baabaaaabbbaba -> aabaaaabbbabba
baabaaaabbbaa -> aabaaaabbbaba
baabaaaabba -> aabaaaabbbababaaaabbbabba
baabaaaaba -> aabaaaabbbababaaaabbbaba
baabaaaaa -> aabaaaabbbababaaaabbbaa

# < a,b | baabaaaabbbbaba=a >
baabaaaabbbbaba -> a
baabaaaabbbbaa -> aabaaaabbbbaba
baabaaaabbba -> aabaaaabbbbababaaaabbbbaba
baabaaaabba -> aabaaaabbbbababaaaabbbbaa
baabaaaaba -> aabaaaabbbbababaaaabbbbaaabaaaabbbbaba
baabaaaaa -> aabaaaabbbbababaaaabbbbaaabaaaabbbbaa

# < a,b | baabaaaabbbbbaa=a >
baabaaaabbbbbaa -> a
baabaaaabbbba -> abaaaabbbbbaa
baabaaaabbba -> abaaaabbbbbaaabaaaabbbbbaa
baabaaaabba -> abaaaabbbbbaaabaaaabbbbbaaabaaaabbbbbaa
baabaaaaba -> abaaaabbbbbaaabaaaabbbbbaaabaaaabbbbbaaabaaaabbbbbaa
baabaaaaa -> abaaaabbbbbaaabaaaabbbbbaaabaaaabbbbbaaabaaaabbbbbaaabaaaabbbbbaa

# < a,b | baabaaabaaababa=a >
baabaaabaaababa -> a
baabaaabaaabaa -> aabaaabaaababa
baabaaabaaaa -> aabaaabaaabababaaabaaababa

# < a,b | baabaaabaaabbaa=a >
baabaaabaaabbaa -> a
baabaaabaaaba -> abaaabaaabbaa
baabaaabaaaa -> abaaabaaabbaaabaaabaaabbaa

# < a,b | baabaaabaabaaba=a >
baabaaabaabaaba -> a
baabaaabaabaaa -> aabaaabaabaaba
baabaaabaaa -> aaabaabaaba
baabaaaa -> aabaaabaabaababaabaaba

# < a,b | baabaaabaababaa=a >
baabaaabaababaa -> a
baabaaabaabaa -> abaaabaababaa
baabaaabaaa -> abaaabaabaa
baabaaaa -> abaaabaababaaabaababaa

# < a,b | baabaaabaababba=a >
baabaaabaababba -> a
baabaaabaababa -> aabaaabaababba
baabaaabaabaa -> aabaaabaababa
baabaaabaaa -> aabaaabaabababaaabaababba
baabaaaa -> aabaaabaababaabaababba

# < a,b | baabaaabaabbaba=a >
baabaaabaabbaba -> a
baabaaabaabbaa -> aabaaabaabbaba
baabaaabaaba -> aabaaabaabbababaaabaabbaba
baabaaabaaa -> aabaaabaabbababaaabaabbaa
baabaaaa -> aabaaabaabbababaaabaabbabaaabaabbaba

# < a,b | baabaaabaabbbaa=a >
baabaaabaabbbaa -> a
baabaaabaabba -> abaaabaabbbaa
baabaaabaaba -> abaaabaabbbaaabaaabaabbbaa
baabaaabaaa -> abaaabaabbbaaabaaabaabbbaaabaaabaabbbaa
baabaaaa -> abaaabaabbbaaabaaabaabbbaaaabaabbbaa

# < a,b | baabaaabaabbbba=a >
baabaaabaabbbba -> a
baabaaabaabbba -> aabaaabaabbbba
baabaaabaabba -> aabaaabaabbba
baabaaabaaba -> aabaaabaabba
baabaaabaaa -> aabaaabaaba
baabaaaa -> aabaaabaabbaaabaabbbba

# < a,b | baabaaababaabba=a >
baabaaababaabba -> a
baabaaababaaba -> aabaaababaabba
baabaaababaaa -> aabaaababaaba
baabaaabaa -> aabaaababaabbaaababaabba
baabaaaa -> aabaaababaabbaaababaabbabaaababaabba

# < a,b | baabaaababababa=a >
baabaaababababa -> a
baabaaabababaa -> aabaaababababa
baabaaababaa -> aabaaabababababaaababababa
baabaaabaa -> aabaaabababababaaabababababaaababababa
baabaaaa -> aabaaabababababaaabababababaaabababababaaababababa

# < a,b | baabaaabababbaa=a >
baabaaabababbaa -> a
baabaaabababa -> abaaabababbaa
baabaaababaa -> abaaabababbaaabaaabababbaa
baabaaabaa -> abaaabababbaaabaaabababa
baabaaaa -> abaaabababbaaabaaababababaaabababbaa

# < a,b | baabaaabababbba=a >
baabaaabababbba -> a
baabaaabababba -> aabaaabababbba
baabaaabababa -> aabaaabababba
baabaaababaa -> aabaaabababa
baabaaabaa -> aabaaababababaaabababbba
baabaaaa -> aabaaababababaaabababbbabaaabababbba

# < a,b | baabaaababbaaba=a >
baabaaababbaaba -> a
baabaaababbaaa -> aabaaababbaaba
baabaaababa -> aaababbaaba
baabaaabaa -> aaababbaaa
baabaaaa -> aaababbaaabaaababbaaba

# < a,b | baabaaababbabaa=a >
baabaaababbabaa -> a
baabaaababbaa -> abaaababbabaa
baabaaababa -> abaaababbaa
baabaaabaa -> abaaababbaaabaaababbabaa
baabaaaa -> abaaababbaaabaaababbaa

# < a,b | baabaaababbabba=a >
baabaaababbabba -> a
baabaaababbaba -> aabaaababbabba
baabaaababbaa -> aabaaababbaba
baabaaababa -> aabaaababbababaaababbabba
baabaaabaa -> aabaaababbababaaababbaba
baabaaaa -> aabaaababbababaaababbababaaababbabba

# < a,b | baabaaababbbaba=a >
baabaaababbbaba -> a
baabaaababbbaa -> aabaaababbbaba
baabaaababba -> aabaaababbbababaaababbbaba
baabaaababa -> aabaaababbbababaaababbbaa
baabaaabaa -> aabaaababbbababaaababbbaaabaaababbbaba
baabaaaa -> aabaaababbbababaaababbbaaabaaababbbababaaababbbaba

# < a,b | baabaaababbbbaa=a >
baabaaababbbbaa -> a
baabaaababbba -> abaaababbbbaa
baabaaababba -> abaaababbbbaaabaaababbbbaa
baabaaababa -> abaaababbbbaaabaaababbbbaaabaaababbbbaa
baabaaabaa -> abaaababbbbaaabaaababbbbaaabaaababbbbaaabaaababbbbaa
baabaaaa -> abaaababbbbaaabaaababbbbaaabaaababbbbaaabaaababbba

# < a,b | baabaaababbbbba=a >
baabaaababbbbba -> a
baabaaababbbba -> aabaaababbbbba
baabaaababbba -> aabaaababbbba
baabaaababba -> aabaaababbba
baabaaababa -> aabaaababba
baabaaabaa -> aabaaababa
baabaaaa -> aabaaabababaaababbbbba

# < a,b | baabaaabbaababa=a >
baabaaabbaababa -> a
baabaaabbaabaa -> aabaaabbaababa
baabaaabbaaa -> aabaaabbaabababaaabbaababa
baabaaaba -> aabaaabbaababaabbaababa
baabaaaa -> aabaaabbaababaabbaabaa

# < a,b | baabaaabbaabbaa=a >
baabaaabbaabbaa -> a
baabaaabbaaba -> abaaabbaabbaa
baabaaabbaaa -> abaaabbaabbaaabaaabbaabbaa
baabaaaba -> abaaabbaabbaaaabbaabbaa
baabaaaa -> abaaabbaabbaaaabbaabbaaabaaabbaabbaa

# < a,b | baabaaabbaabbba=a >
baabaaabbaabbba -> a
baabaaabbaabba -> aabaaabbaabbba
baabaaabbaaba -> aabaaabbaabba
baabaaabbaaa -> aabaaabbaaba
baabaaaba -> aabaaabbaabbaaabbaabbba
baabaaaa -> aabaaabbaabbaaabbaabba

# < a,b | baabaaabbabaaba=a >
baabaaabbabaaba -> a
baabaaabbabaaa -> aabaaabbabaaba
baabaaabbaa -> aaabbabaaba
baabaaaba -> aaabbabaababaaabbabaaba
baabaaaa -> aaabbabaababaaabbabaaa

# < a,b | baabaaabbababaa=a >
baabaaabbababaa -> a
baabaaabbabaa -> abaaabbababaa
baabaaabbaa -> abaaabbabaa
baabaaaba -> abaaabbaa
baabaaaa -> abaaabbaaabaaabbababaa

# < a,b | baabaaabbababba=a >
baabaaabbababba -> a
baabaaabbababa -> aabaaabbababba
baabaaabbabaa -> aabaaabbababa
baabaaabbaa -> aabaaabbabababaaabbababba
baabaaaba -> aabaaabbabababaaabbababbabaaabbababba
baabaaaa -> aabaaabbabababaaabbababbabaaabbababa

# < a,b | baabaaabbabbaba=a >
baabaaabbabbaba -> a
baabaaabbabbaa -> aabaaabbabbaba
baabaaabbaba -> aabaaabbabbababaaabbabbaba
baabaaabbaa -> aabaaabbabbababaaabbabbaa
baabaaaba -> aabaaabbabbababaaabbaba
baabaaaa -> aabaaabbabbababaaabbaa

# < a,b | baabaaabbabbbaa=a >
baabaaabbabbbaa -> a
baabaaabbabba -> abaaabbabbbaa
baabaaabbaba -> abaaabbabbbaaabaaabbabbbaa
baabaaabbaa -> abaaabbabbbaaabaaabbabbbaaabaaabbabbbaa
baabaaaba -> abaaabbabbbaaabaaabbabbbaaabaaabbabba
baabaaaa -> abaaabbabbbaaabaaabbabbbaaabaaabbaba

# < a,b | baabaaabbabbbba=a >
baabaaabbabbbba -> a
baabaaabbabbba -> aabaaabbabbbba
baabaaabbabba -> aabaaabbabbba
baabaaabbaba -> aabaaabbabba
baabaaabbaa -> aabaaabbaba
baabaaaba -> aabaaabbababaaabbabbbba
baabaaaa -> aabaaabbababaaabbabbba

# < a,b | baabaaabbbaabba=a >
baabaaabbbaabba -> a
baabaaabbbaaba -> aabaaabbbaabba
baabaaabbbaaa -> aabaaabbbaaba
baabaaabba -> aabaaabbbaabbaaabbbaabba
baabaaaba -> aabaaabbbaabbaaabbbaaba
baabaaaa -> aabaaabbbaabbaaabbbaaa

# < a,b | baabaaabbbababa=a >
baabaaabbbababa -> a
baabaaabbbabaa -> aabaaabbbababa
baabaaabbbaa -> aabaaabbbabababaaabbbababa
baabaaabba -> aabaaabbbabababaaabbbabababaaabbbababa
baabaaaba -> aabaaabbbabababaaabbbabababaaabbbabaa
baabaaaa -> aabaaabbbabababaaabbbabababaaabbbabaaabaaabbbababa

# < a,b | baabaaabbbabbaa=a >
baabaaabbbabbaa -> a
baabaaabbbaba -> abaaabbbabbaa
baabaaabbbaa -> abaaabbbabbaaabaaabbbabbaa
baabaaabba -> abaaabbbabbaaabaaabbbaba
baabaaaba -> abaaabbbabbaaabaaabbbaa
baabaaaa -> abaaabbbabbaaabaaabbbaaabaaabbbabbaa

# < a,b | baabaaabbbabbba=a >
baabaaabbbabbba -> a
baabaaabbbabba -> aabaaabbbabbba
baabaaabbbaba -> aabaaabbbabba
baabaaabbbaa -> aabaaabbbaba
baabaaabba -> aabaaabbbababaaabbbabbba
baabaaaba -> aabaaabbbababaaabbbabba
baabaaaa -> aabaaabbbababaaabbbaba

# < a,b | baabaaabbbbaaba=a >
baabaaabbbbaaba -> a
baabaaabbbbaaa -> aabaaabbbbaaba
baabaaabbba -> aaabbbbaaba
baabaaabba -> aaabbbbaaa
baabaaaba -> aaabbbbaaaabaaabbbbaaba
baabaaaa -> aaabbbbaaaabaaabbbbaaa

# < a,b | baabaaabbbbabaa=a >
baabaaabbbbabaa -> a
baabaaabbbbaa -> abaaabbbbabaa
baabaaabbba -> abaaabbbbaa
baabaaabba -> abaaabbbbaaabaaabbbbabaa
baabaaaba -> abaaabbbbaaabaaabbbbabaaabaaabbbbabaa
baabaaaa -> abaaabbbbaaabaaabbbbabaaabaaabbbbabaaabaaabbbbabaa

# < a,b | baabaaabbbbabba=a >
baabaaabbbbabba -> a
baabaaabbbbaba -> aabaaabbbbabba
baabaaabbbbaa -> aabaaabbbbaba
baabaaabbba -> aabaaabbbbababaaabbbbabba
baabaaabba -> aabaaabbbbababaaabbbbaba
baabaaaba -> aabaaabbbbababaaabbbbaa
baabaaaa -> aabaaabbbbababaaabbbbaaabaaabbbbabba

# < a,b | baabaaabbbbbaba=a >
baabaaabbbbbaba -> a
baabaaabbbbbaa -> aabaaabbbbbaba
baabaaabbbba -> aabaaabbbbbababaaabbbbbaba
baabaaabbba -> aabaaabbbbbababaaabbbbbaa
baabaaabba -> aabaaabbbbbababaaabbbbbaaabaaabbbbbaba
baabaaaba -> aabaaabbbbbababaaabbbbbaaabaaabbbbbaa
baabaaaa -> aabaaabbbbbababaaabbbbbaaabaaabbbbbaaabaaabbbbbaba

# < a,b | baabaaabbbbbbaa=a >
baabaaabbbbbbaa -> a
baabaaabbbbba -> abaaabbbbbbaa
baabaaabbbba -> abaaabbbbbbaaabaaabbbbbbaa
baabaaabbba -> abaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaa
baabaaabba -> abaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaa
baabaaaba -> abaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaa
baabaaaa -> abaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaaabaaabbbbbbaa

# < a,b | baabaabaaaababa=a >
baabaabaaaababa -> a
baabaabaaaabaa -> aabaabaaaababa
baabaabaaaaa -> aabaabaaaabababaabaaaababa

# < a,b | baabaabaaaabbaa=a >
baabaabaaaabbaa -> a
baabaabaaaaba -> abaabaaaabbaa
baabaabaaaaa -> abaabaaaabbaaabaabaaaabbaa

# < a,b | baabaabaaababba=a >
baabaabaaababba -> a
baabaabaaababa -> aabaabaaababba
baabaabaaabaa -> aabaabaaababa
baabaabaaaa -> aabaabaaabababaabaaababba

# < a,b | baabaabaaabbaba=a >
baabaabaaabbaba -> a
baabaabaaabbaa -> aabaabaaabbaba
baabaabaaaba -> aabaabaaabbababaabaaabbaba
baabaabaaaa -> aabaabaaabbababaabaaabbaa

# < a,b | baabaabaaabbbaa=a >
baabaabaaabbbaa -> a
baabaabaaabba -> abaabaaabbbaa
baabaabaaaba -> abaabaaabbbaaabaabaaabbbaa
baabaabaaaa -> abaabaaabbbaaabaabaaabbbaaabaabaaabbbaa

# < a,b | baabaabaabaabba=a >
baabaabaabaabba -> a
baabaabaabaaba -> aabaabaabaabba
baaa -> aabaabaabaabbaabba

# < a,b | baabaabaabababa=a >
baabaabaabababa -> a
baabaabaababaa -> aabaabaabababa
baabaabaabaa -> aabaabaababababaabaabababa
baaa -> aabaabaababababaabaababababababa

# < a,b | baabaabaababbba=a >
baabaabaababbba -> a
baabaabaababba -> aabaabaababbba
baabaabaababa -> aabaabaababba
baabaabaabaa -> aabaabaababa
baaa -> aabaabaababababbba

# < a,b | baabaabaabbaaba=a >
baabaabaabbaaba -> a
baabaabaaba -> aabaabbaaba
baaa -> aabaabbaabaabbaaba

# < a,b | baabaabaabbabba=a >
baabaabaabbabba -> a
baabaabaabbaba -> aabaabaabbabba
baabaabaabbaa -> aabaabaabbaba
baabaabaaba -> aabaabaabbababaabaabbabba
baaa -> aabaabaabbababaabaabbabbaabbabba

# < a,b | baabaabaabbbbba=a >
baabaabaabbbbba -> a
baabaabaabbbba -> aabaabaabbbbba
baabaabaabbba -> aabaabaabbbba
baabaabaabba -> aabaabaabbba
baabaabaaba -> aabaabaabba
baaa -> aabaabaabbaabbbbba

# < a,b | baabaababaababa=a >
baabaababaababa -> a
baabaababaabaa -> aabaababaababa
baabaabaa -> aabaababaababababaababa
baaa -> aabaababaababababaababababaababa

# < a,b | baabaababaabbba=a >
baabaababaabbba -> a
baabaababaabba -> aabaababaabbba
baabaababaaba -> aabaababaabba
baabaabaa -> aabaababaabbaababaabbba
baaa -> aabaababaabbaababaabbbababaabbba

# < a,b | baabaabababaaba=a >
baabaabababaaba -> a
baabaababaa -> aabababaaba
baabaabaa -> aabababaababaabababaaba
baaa -> aabababaababaabababaababababaaba

# < a,b | baabaababababaa=a >
baabaababababaa -> a
baabaabababaa -> abaababababaa
baabaababaa -> abaabababaa
baabaabaa -> abaababaa
baaa -> abaababaababababaa

# < a,b | baabaababababba=a >
baabaababababba -> a
baabaababababa -> aabaababababba
baabaabababaa -> aabaababababa
baabaababaa -> aabaabababababaababababba
baabaabaa -> aabaabababababaababababbabaababababba
baaa -> aabaabababababaababababbabaababababbababababba

# < a,b | baabaabababbaba=a >
baabaabababbaba -> a
baabaabababbaa -> aabaabababbaba
baabaabababa -> aabaabababbababaabababbaba
baabaababaa -> aabaabababbababaabababbaa
baabaabaa -> aabaabababbababaabababa
baaa -> aabaabababbababaababababababbaba

# < a,b | baabaabababbbba=a >
baabaabababbbba -> a
baabaabababbba -> aabaabababbbba
baabaabababba -> aabaabababbba
baabaabababa -> aabaabababba
baabaababaa -> aabaabababa
baabaabaa -> aabaababababaabababbbba
baaa -> aabaababababaabababbbbabababbbba

# < a,b | baabaababbaabba=a >
baabaababbaabba -> a
baabaababbaaba -> aabaababbaabba
baabaababa -> aabaababbaabbaababbaabba
baabaabaa -> aabaababbaabbaababbaaba
baaa -> aabaababbaabbaababbaabababbaabba

# < a,b | baabaababbababa=a >
baabaababbababa -> a
baabaababbabaa -> aabaababbababa
baabaababbaa -> aabaababbabababaababbababa
baabaababa -> aabaababbabababaababbabababaababbababa
baabaabaa -> aabaababbabababaababbabababaababbabaa
baaa -> aabaababbabababaababbabababaababbabaababbababa

# < a,b | baabaababbabbba=a >
baabaababbabbba -> a
baabaababbabba -> aabaababbabbba
baabaababbaba -> aabaababbabba
baabaababbaa -> aabaababbaba
baabaababa -> aabaababbababaababbabbba
baabaabaa -> aabaababbababaababbabba
baaa -> aabaababbababaababbabbababbabbba

# < a,b | baabaababbbabba=a >
baabaababbbabba -> a
baabaababbbaba -> aabaababbbabba
baabaababbbaa -> aabaababbbaba
baabaababba -> aabaababbbababaababbbabba
baabaababa -> aabaababbbababaababbbaba
baabaabaa -> aabaababbbababaababbbaa
baaa -> aabaababbbababaababbbaababbbabba

# < a,b | baabaababbbbbba=a >
baabaababbbbbba -> a
baabaababbbbba -> aabaababbbbbba
baabaababbbba -> aabaababbbbba
baabaababbba -> aabaababbbba
baabaababba -> aabaababbba
baabaababa -> aabaababba
baabaabaa -> aabaababa
baaa -> aabaababababbbbbba

# < a,b | baabaabbaaababa=a >
baabaabbaaababa -> a
baabaabbaaabaa -> aabaabbaaababa
baabaabbaaaa -> aabaabbaaabababaabbaaababa

# < a,b | baabaabbaaabbaa=a >
baabaabbaaabbaa -> a
baabaabbaaaba -> abaabbaaabbaa
baabaabbaaaa -> abaabbaaabbaaabaabbaaabbaa

# < a,b | baabaabbaababba=a >
baabaabbaababba -> a
baabaabbaababa -> aabaabbaababba
baabaabbaabaa -> aabaabbaababa
baabaaba -> aabaabbaabababbaababba
baaa -> aabaabbaabababbaababbaabbaababba

# < a,b | baabaabbaabbaba=a >
baabaabbaabbaba -> a
baabaabbaabbaa -> aabaabbaabbaba
baabaabbaaba -> aabaabbaabbababaabbaabbaba
baabaaba -> aabaabbaabbababaabbaabbabaabbaabbaba
baaa -> aabaabbaabbababaabbaabbabaabbaabbabaabbaabbaba

# < a,b | baabaabbaabbbba=a >
baabaabbaabbbba -> a
baabaabbaabbba -> aabaabbaabbbba
baabaabbaabba -> aabaabbaabbba
baabaabbaaba -> aabaabbaabba
baabaaba -> aabaabbaabbaabbaabbbba
baaa -> aabaabbaabbaabbaabbbbaabbaabbbba

# < a,b | baabaabbabaabba=a >
baabaabbabaabba -> a
baabaabbabaaba -> aabaabbabaabba
baabaabbaa -> aabaabbabaabbaabbabaabba
baabaaba -> aabaabbabaabbaabbabaabbabaabbabaabba
baaa -> aabaabbabaabbaabbabaabbabaabbabaabbaabbabaabba

# < a,b | baabaabbabababa=a >
baabaabbabababa -> a
baabaabbababaa -> aabaabbabababa
baabaabbabaa -> aabaabbababababaabbabababa
baabaabbaa -> aabaabbababababaabbababababaabbabababa
baabaaba -> aabaabbababababaabbababababaabbababababaabbabababa
baaa -> aabaabbababababaabbababababaabbababababaabbabababaabbabababa

# < a,b | baabaabbababbba=a >
baabaabbababbba -> a
baabaabbababba -> aabaabbababbba
baabaabbababa -> aabaabbababba
baabaabbabaa -> aabaabbababa
baabaabbaa -> aabaabbabababaabbababbba
baabaaba -> aabaabbabababaabbababbbabaabbababbba
baaa -> aabaabbabababaabbababbbabaabbababbbaabbababbba

# < a,b | baabaabbabbabba=a >
baabaabbabbabba -> a
baabaabbabbaba -> aabaabbabbabba
baabaabbabbaa -> aabaabbabbaba
baabaabbaba -> aabaabbabbababaabbabbabba
baabaabbaa -> aabaabbabbababaabbabbaba
baabaaba -> aabaabbabbababaabbabbababaabbabbabba
baaa -> aabaabbabbababaabbabbababaabbabbabbaabbabbabba

# < a,b | baabaabbabbbbba=a >
baabaabbabbbbba -> a
baabaabbabbbba -> aabaabbabbbbba
baabaabbabbba -> aabaabbabbbba
baabaabbabba -> aabaabbabbba
baabaabbaba -> aabaabbabba
baabaabbaa -> aabaabbaba
baabaaba -> aabaabbababaabbabbbbba
baaa -> aabaabbababaabbabbbbbaabbabbbbba

# < a,b | baabaabbbaabbba=a >
baabaabbbaabbba -> a
baabaabbbaabba -> aabaabbbaabbba
baabaabbbaaba -> aabaabbbaabba
baabaabba -> aabaabbbaabbaabbbaabbba
baabaaba -> aabaabbbaabbaabbbaabba
baaa -> aabaabbbaabbaabbbaabbaabbbaabbba

# < a,b | baabaabbbababba=a >
baabaabbbababba -> a
baabaabbbababa -> aabaabbbababba
baabaabbbabaa -> aabaabbbababa
baabaabbbaa -> aabaabbbabababaabbbababba
baabaabba -> aabaabbbabababaabbbababbabaabbbababba
baabaaba -> aabaabbbabababaabbbababbabaabbbababa
baaa -> aabaabbbabababaabbbababbabaabbbababaabbbababba

# < a,b | baabaabbbabbbba=a >
baabaabbbabbbba -> a
baabaabbbabbba -> aabaabbbabbbba
baabaabbbabba -> aabaabbbabbba
baabaabbbaba -> aabaabbbabba
baabaabbbaa -> aabaabbbaba
baabaabba -> aabaabbbababaabbbabbbba
baabaaba -> aabaabbbababaabbbabbba
baaa -> aabaabbbababaabbbabbbaabbbabbbba

# < a,b | baabaabbbbabbba=a >
baabaabbbbabbba -> a
baabaabbbbabba -> aabaabbbbabbba
baabaabbbbaba -> aabaabbbbabba
baabaabbbbaa -> aabaabbbbaba
baabaabbba -> aabaabbbbababaabbbbabbba
baabaabba -> aabaabbbbababaabbbbabba
baabaaba -> aabaabbbbababaabbbbaba
baaa -> aabaabbbbababaabbbbabaabbbbabbba

# < a,b | baabaabbbbbbbba=a >
baabaabbbbbbbba -> a
baabaabbbbbbba -> aabaabbbbbbbba
baabaabbbbbba -> aabaabbbbbbba
baabaabbbbba -> aabaabbbbbba
baabaabbbba -> aabaabbbbba
baabaabbba -> aabaabbbba
baabaabba -> aabaabbba
baabaaba -> aabaabba
baaa -> aabaabbaabbbbbbbba

# < a,b | baababaaaaababa=a >
baababaaaaababa -> a
baababaaaaabaa -> aababaaaaababa
baababaaaaaa -> aababaaaaababababaaaaababa

# < a,b | baababaaaaabbaa=a >
baababaaaaabbaa -> a
baababaaaaaba -> ababaaaaabbaa
baababaaaaaa -> ababaaaaabbaaababaaaaabbaa

# < a,b | baababaaaababba=a >
baababaaaababba -> a
baababaaaababa -> aababaaaababba
baababaaaabaa -> aababaaaababa
baababaaaaa -> aababaaaababababaaaababba

# < a,b | baababaaaabbaba=a >
baababaaaabbaba -> a
baababaaaabbaa -> aababaaaabbaba
baababaaaaba -> aababaaaabbabababaaaabbaba
baababaaaaa -> aababaaaabbabababaaaabbaa

# < a,b | baababaaaabbbaa=a >
baababaaaabbbaa -> a
baababaaaabba -> ababaaaabbbaa
baababaaaaba -> ababaaaabbbaaababaaaabbbaa
baababaaaaa -> ababaaaabbbaaababaaaabbbaaababaaaabbbaa

# < a,b | baababaaabaabba=a >
baababaaabaabba -> a
baababaaabaaba -> aababaaabaabba
baababaaabaaa -> aababaaabaaba
baababaaaa -> aababaaabaabbabaaabaabba

# < a,b | baababaaabababa=a >
baababaaabababa -> a
baababaaababaa -> aababaaabababa
baababaaabaa -> aababaaabababababaaabababa
baababaaaa -> aababaaabababababaaabababababaaabababa

# < a,b | baababaaababbaa=a >
baababaaababbaa -> a
baababaaababa -> ababaaababbaa
baababaaabaa -> ababaaababbaaababaaababbaa
baababaaaa -> ababaaababbaaababaaababa

# < a,b | baababaaababbba=a >
baababaaababbba -> a
baababaaababba -> aababaaababbba
baababaaababa -> aababaaababba
baababaaabaa -> aababaaababa
baababaaaa -> aababaaababababaaababbba

# < a,b | baababaaabbabaa=a >
baababaaabbabaa -> a
baababaaabbaa -> ababaaabbabaa
baababaaaba -> ababaaabbaa
baababaaaa -> ababaaabbaaababaaabbabaa

# < a,b | baababaaabbabba=a >
baababaaabbabba -> a
baababaaabbaba -> aababaaabbabba
baababaaabbaa -> aababaaabbaba
baababaaaba -> aababaaabbabababaaabbabba
baababaaaa -> aababaaabbabababaaabbaba

# < a,b | baababaaabbbaba=a >
baababaaabbbaba -> a
baababaaabbbaa -> aababaaabbbaba
baababaaabba -> aababaaabbbabababaaabbbaba
baababaaaba -> aababaaabbbabababaaabbbaa
baababaaaa -> aababaaabbbabababaaabbbaaababaaabbbaba

# < a,b | baababaaabbbbaa=a >
baababaaabbbbaa -> a
baababaaabbba -> ababaaabbbbaa
baababaaabba -> ababaaabbbbaaababaaabbbbaa
baababaaaba -> ababaaabbbbaaababaaabbbbaaababaaabbbbaa
baababaaaa -> ababaaabbbbaaababaaabbbbaaababaaabbbbaaababaaabbbbaa

# < a,b | baababaabaababa=a >
baababaabaababa -> a
baababaabaabaa -> aababaabaababa
baababaaa -> aabaababa
baababaabaaa -> aababaabaababababaabaababa

# < a,b | baababaabaabbaa=a >
baababaabaabbaa -> a
baababaabaaba -> ababaabaabbaa
baababaabaaa -> ababaabaabbaaababaabaabbaa
baababaaa -> ababaabaabbaabaabaabbaa

# < a,b | baababaabaabbba=a >
baababaabaabbba -> a
baababaabaabba -> aababaabaabbba
baababaabaaba -> aababaabaabba
baababaabaaa -> aababaabaaba
baababaaa -> aababaabaabbabaabaabbba

# < a,b | baababaababaaba=a >
baababaababaaba -> a
baabaa -> abaaba
baaa -> abaabababaababaaba

# < a,b | baababaabababaa=a >
baababaabababaa -> a
baababaababaa -> ababaabababaa
baabaa -> ababaabababaabababaa
baaa -> ababaabababaababaa

# < a,b | baababaabababba=a >
baababaabababba -> a
baababaabababa -> aababaabababba
baababaababaa -> aababaabababa
baabaa -> aababaababababababba
baaa -> aababaababababababbababaabababba

# < a,b | baababaababbaba=a >
baababaababbaba -> a
baababaababbaa -> aababaababbaba
baababaababa -> aababaababbabababaababbaba
baabaa -> aababaababbabababaababbabaababbaba
baaa -> aababaababbabababaababbabaababbabababaababbaba

# < a,b | baababaababbbba=a >
baababaababbbba -> a
baababaababbba -> aababaababbbba
baababaababba -> aababaababbba
baababaababa -> aababaababba
baabaa -> aababaababbaababbbba
baaa -> aababaababbaababbbbababaababbbba

# < a,b | baababaabbaabba=a >
baababaabbaabba -> a
baababaabbaaba -> aababaabbaabba
baababaaba -> aababaabbaabbabaabbaabba
baabaa -> aababaabbaabbabaabbaabbabaabbaabba
baaa -> aababaabbaabbabaabbaabbabaabbaabbababaabbaabba

# < a,b | baababaabbababa=a >
baababaabbababa -> a
baababaabbabaa -> aababaabbababa
baababaabbaa -> aababaabbababababaabbababa
baababaaba -> aababaabbababababaabbababababaabbababa
baabaa -> aababaabbababababaabbababababaabbabababaabbababa
baaa -> aababaabbababababaabbababababaabbabababaabbababababaabbababa

# < a,b | baababaabbabbba=a >
baababaabbabbba -> a
baababaabbabba -> aababaabbabbba
baababaabbaba -> aababaabbabba
baababaabbaa -> aababaabbaba
baababaaba -> aababaabbabababaabbabbba
baabaa -> aababaabbabababaabbabbbabaabbabbba
baaa -> aababaabbabababaabbabbbabaabbabbbababaabbabbba

# < a,b | baababaabbbabba=a >
baababaabbbabba -> a
baababaabbbaba -> aababaabbbabba
baababaabbbaa -> aababaabbbaba
baababaabba -> aababaabbbabababaabbbabba
baababaaba -> aababaabbbabababaabbbaba
baabaa -> aababaabbbabababaabbbababaabbbabba
baaa -> aababaabbbabababaabbbababaabbbabbababaabbbabba

# < a,b | baababaabbbbbba=a >
baababaabbbbbba -> a
baababaabbbbba -> aababaabbbbbba
baababaabbbba -> aababaabbbbba
baababaabbba -> aababaabbbba
baababaabba -> aababaabbba
baababaaba -> aababaabba
baabaa -> aababaabbabaabbbbbba
baaa -> aababaabbabaabbbbbbababaabbbbbba

# < a,b | baabababaaababa=a >
baabababaaababa -> a
baabababaaabaa -> aabababaaababa
baabababaaaa -> aabababaaabababababaaababa

# < a,b | baabababaaabbaa=a >
baabababaaabbaa -> a
baabababaaaba -> abababaaabbaa
baabababaaaa -> abababaaabbaaabababaaabbaa

# < a,b | baabababaababba=a >
baabababaababba -> a
baabababaababa -> aabababaababba
baababaa -> aabababaababbabaababba
baabaa -> aabababaababbabaababbabababaababba
baaa -> aabababaababbabaababbabababaababbabababaababba

# < a,b | baabababaabbaba=a >
baabababaabbaba -> a
baabababaabbaa -> aabababaabbaba
baabababaaba -> aabababaabbababababaabbaba
baababaa -> aabababaabbababababaabbabababaabbaba
baabaa -> aabababaabbababababaabbabababaabbababababaabbaba
baaa -> aabababaabbababababaabbabababaabbababababaabbababababaabbaba

# < a,b | baabababaabbbba=a >
baabababaabbbba -> a
baabababaabbba -> aabababaabbbba
baabababaabba -> aabababaabbba
baabababaaba -> aabababaabba
baababaa -> aabababaabbababaabbbba
baabaa -> aabababaabbababaabbbbabababaabbbba
baaa -> aabababaabbababaabbbbabababaabbbbabababaabbbba

# < a,b | baababababaabba=a >
baababababaabba -> a
baababababaaba -> aababababaabba
baabababaa -> aababababaabbabababaabba
baababaa -> aababababaabbabababaabbababababaabba
baabaa -> aababababaabbabababaabbababababaabbababababaabba
baaa -> aababababaabbabababaabbababababaabbababababaabbababababaabba

# < a,b | baababababababa=a >
baababababababa -> a
baabababababaa -> aababababababa
baababababaa -> aababababababababababababa
baabababaa -> aababababababababababababababababababa
baababaa -> aababababababababababababababababababababababababa
baabaa -> aababababababababababababababababababababababababababababababa
baaa -> aababababababababababababababababababababababababababababababababababababa

# < a,b | baabababababbba=a >
baabababababbba -> a
baabababababba -> aabababababbba
baabababababa -> aabababababba
baababababaa -> aabababababa
baabababaa -> aababababababababababbba
baababaa -> aababababababababababbbabababababbba
baabaa -> aababababababababababbbabababababbbabababababbba
baaa -> aababababababababababbbabababababbbabababababbbabababababbba

# < a,b | baababababbabba=a >
baababababbabba -> a
baababababbaba -> aababababbabba
baababababbaa -> aababababbaba
baababababa -> aababababbabababababbabba
baabababaa -> aababababbabababababbaba
baababaa -> aababababbabababababbabababababbabba
baabaa -> aababababbabababababbabababababbabbababababbabba
baaa -> aababababbabababababbabababababbabbababababbabbababababbabba

# < a,b | baababababbbbba=a >
baababababbbbba -> a
baababababbbba -> aababababbbbba
baababababbba -> aababababbbba
baababababba -> aababababbba
baababababa -> aababababba
baabababaa -> aababababa
baababaa -> aababababababababbbbba
baabaa -> aababababababababbbbbababababbbbba
baaa -> aababababababababbbbbababababbbbbababababbbbba

# < a,b | baabababbaabbba=a >
baabababbaabbba -> a
baabababbaabba -> aabababbaabbba
baabababbaaba -> aabababbaabba
baabababa -> aabababbaabbababbaabbba
baababaa -> aabababbaabbababbaabba
baabaa -> aabababbaabbababbaabbabababbaabbba
baaa -> aabababbaabbababbaabbabababbaabbbabababbaabbba

# < a,b | baabababbababba=a >
baabababbababba -> a
baabababbababa -> aabababbababba
baabababbabaa -> aabababbababa
baabababbaa -> aabababbabababababbababba
baabababa -> aabababbabababababbababbabababbababba
baababaa -> aabababbabababababbababbabababbababa
baabaa -> aabababbabababababbababbabababbabababababbababba
baaa -> aabababbabababababbababbabababbabababababbababbabababbababba

# < a,b | baabababbabbaba=a >
baabababbabbaba -> a
baabababbabbaa -> aabababbabbaba
baabababbaba -> aabababbabbababababbabbaba
baabababbaa -> aabababbabbababababbabbaa
baabababa -> aabababbabbababababbaba
baababaa -> aabababbabbababababbaa
baabaa -> aabababbabbababababa
baaa -> aabababbabbabababababababbabbaba

# < a,b | baabababbabbbba=a >
baabababbabbbba -> a
baabababbabbba -> aabababbabbbba
baabababbabba -> aabababbabbba
baabababbaba -> aabababbabba
baabababbaa -> aabababbaba
baabababa -> aabababbababababbabbbba
baababaa -> aabababbababababbabbba
baabaa -> aabababbababababbabbbabababbabbbba
baaa -> aabababbababababbabbbabababbabbbbabababbabbbba

# < a,b | baabababbbabbba=a >
baabababbbabbba -> a
baabababbbabba -> aabababbbabbba
baabababbbaba -> aabababbbabba
baabababbbaa -> aabababbbaba
baabababba -> aabababbbababababbbabbba
baabababa -> aabababbbababababbbabba
baababaa -> aabababbbababababbbaba
baabaa -> aabababbbababababbbababababbbabbba
baaa -> aabababbbababababbbababababbbabbbabababbbabbba

# < a,b | baabababbbbbbba=a >
baabababbbbbbba -> a
baabababbbbbba -> aabababbbbbbba
baabababbbbba -> aabababbbbbba
baabababbbba -> aabababbbbba
baabababbba -> aabababbbba
baabababba -> aabababbba
baabababa -> aabababba
baababaa -> aabababa
baabaa -> aababababababbbbbbba
baaa -> aababababababbbbbbbabababbbbbbba

# < a,b | baababbaaaababa=a >
baababbaaaababa -> a
baababbaaaabaa -> aababbaaaababa
baababbaaaaa -> aababbaaaababababbaaaababa

# < a,b | baababbaaaabbaa=a >
baababbaaaabbaa -> a
baababbaaaaba -> ababbaaaabbaa
baababbaaaaa -> ababbaaaabbaaababbaaaabbaa

# < a,b | baababbaaababba=a >
baababbaaababba -> a
baababbaaababa -> aababbaaababba
baababbaaabaa -> aababbaaababa
baababbaaaa -> aababbaaababababbaaababba

# < a,b | baababbaaabbaba=a >
baababbaaabbaba -> a
baababbaaabbaa -> aababbaaabbaba
baababbaaaba -> aababbaaabbabababbaaabbaba
baababbaaaa -> aababbaaabbabababbaaabbaa

# < a,b | baababbaaabbbaa=a >
baababbaaabbbaa -> a
baababbaaabba -> ababbaaabbbaa
baababbaaaba -> ababbaaabbbaaababbaaabbbaa
baababbaaaa -> ababbaaabbbaaababbaaabbbaaababbaaabbbaa

# < a,b | baababbaabaabba=a >
baababbaabaabba -> a
baababbaabaaba -> aababbaabaabba
baababbaabaaa -> aababbaabaaba
baababbaaa -> aababbaabaabbabbaabaabba

# < a,b | baababbaabababa=a >
baababbaabababa -> a
baababbaababaa -> aababbaabababa
baababbaabaa -> aababbaabababababbaabababa
baababbaaa -> aababbaabababababbaabababababbaabababa

# < a,b | baababbaababbba=a >
baababbaababbba -> a
baababbaababba -> aababbaababbba
baababa -> aababbaababbbaababbba
baabaa -> aababbaababbbaababba
baaa -> aababbaababbbaababbababbaababbba

# < a,b | baababbaabbabba=a >
baababbaabbabba -> a
baababbaabbaba -> aababbaabbabba
baababbaabbaa -> aababbaabbaba
baababbaaba -> aababbaabbabababbaabbabba
baababa -> aababbaabbabababbaabbabbabbaabbabba
baabaa -> aababbaabbabababbaabbabbabbaabbaba
baaa -> aababbaabbabababbaabbabbabbaabbabababbaabbabba

# < a,b | baababbaabbbaba=a >
baababbaabbbaba -> a
baababbaabbbaa -> aababbaabbbaba
baababbaabba -> aababbaabbbabababbaabbbaba
baababbaaba -> aababbaabbbabababbaabbbaa
baababa -> aababbaabbbabababbaabbbaabbaabbbaba
baabaa -> aababbaabbbabababbaabbbaabbaabbbaa
baaa -> aababbaabbbabababbaabbbaabbaabba

# < a,b | baababbaabbbbba=a >
baababbaabbbbba -> a
baababbaabbbba -> aababbaabbbbba
baababbaabbba -> aababbaabbbba
baababbaabba -> aababbaabbba
baababbaaba -> aababbaabba
baababa -> aababbaabbabbaabbbbba
baabaa -> aababbaabbabbaabbbba
baaa -> aababbaabbabbaabbbbababbaabbbbba

# < a,b | baababbabaababa=a >
baababbabaababa -> a
baababbabaabaa -> aababbabaababa
baababbabaaa -> aababbabaababababbabaababa

# < a,b | baababbabaabbba=a >
baababbabaabbba -> a
baababbabaabba -> aababbabaabbba
baababbabaaba -> aababbabaabba
baababbaa -> aababbabaabbabbabaabbba
baababa -> aababbabaabbabbabaabbbababbabaabbba
baabaa -> aababbabaabbabbabaabbbababbabaabba
baaa -> aababbabaabbabbabaabbbababbabaabbababbabaabbba

# < a,b | baababbabababba=a >
baababbabababba -> a
baababbabababa -> aababbabababba
baababbababaa -> aababbabababa
baababbabaa -> aababbabababababbabababba
baababbaa -> aababbabababababbabababbababbabababba
baababa -> aababbabababababbabababbababbabababbababbabababba
baabaa -> aababbabababababbabababbababbabababbababbabababa
baaa -> aababbabababababbabababbababbabababbababbabababababbabababba

# < a,b | baababbababbaba=a >
baababbababbaba -> a
baababbababbaa -> aababbababbaba
baababbababa -> aababbababbabababbababbaba
baababbabaa -> aababbababbabababbababbaa
baababbaa -> aababbababbabababbababa
baababa -> aababbababbabababbababababbababbaba
baabaa -> aababbababbabababbababababbababbaa
baaa -> aababbababbabababbababababbababa

# < a,b | baababbababbbba=a >
baababbababbbba -> a
baababbababbba -> aababbababbbba
baababbababba -> aababbababbba
baababbababa -> aababbababba
baababbabaa -> aababbababa
baababbaa -> aababbababababbababbbba
baababa -> aababbababababbababbbbababbababbbba
baabaa -> aababbababababbababbbbababbababbba
baaa -> aababbababababbababbbbababbababbbababbababbbba

# < a,b | baababbabbabbba=a >
baababbabbabbba -> a
baababbabbabba -> aababbabbabbba
baababbabbaba -> aababbabbabba
baababbabbaa -> aababbabbaba
baababbaba -> aababbabbabababbabbabbba
baababbaa -> aababbabbabababbabbabba
baababa -> aababbabbabababbabbabbababbabbabbba
baabaa -> aababbabbabababbabbabbababbabbabba
baaa -> aababbabbabababbabbabbababbabbabbababbabbabbba

# < a,b | baababbabbbabba=a >
baababbabbbabba -> a
baababbabbbaba -> aababbabbbabba
baababbabbbaa -> aababbabbbaba
baababbabba -> aababbabbbabababbabbbabba
baababbaba -> aababbabbbabababbabbbaba
baababbaa -> aababbabbbabababbabbbaa
baababa -> aababbabbbabababbabba
baabaa -> aababbabbbabababbaba
baaa -> aababbabbbabababbabababbabbbabba

# < a,b | baababbabbbbbba=a >
baababbabbbbbba -> a
baababbabbbbba -> aababbabbbbbba
baababbabbbba -> aababbabbbbba
baababbabbba -> aababbabbbba
baababbabba -> aababbabbba
baababbaba -> aababbabba
baababbaa -> aababbaba
baababa -> aababbabababbabbbbbba
baabaa -> aababbabababbabbbbba
baaa -> aababbabababbabbbbbababbabbbbbba

# < a,b | baababbbaaababa=a >
baababbbaaababa -> a
baababbbaaabaa -> aababbbaaababa
baababbbaaaa -> aababbbaaababababbbaaababa

# < a,b | baababbbaaabbaa=a >
baababbbaaabbaa -> a
baababbbaaaba -> ababbbaaabbaa
baababbbaaaa -> ababbbaaabbaaababbbaaabbaa

# < a,b | baababbbaababba=a >
baababbbaababba -> a
baababbbaababa -> aababbbaababba
baababbbaabaa -> aababbbaababa
baababbbaaa -> aababbbaababababbbaababba

# < a,b | baababbbaabbbba=a >
baababbbaabbbba -> a
baababbbaabbba -> aababbbaabbbba
baababbbaabba -> aababbbaabbba
baababbbaaba -> aababbbaabba
baababba -> aababbbaabbabbbaabbbba
baababa -> aababbbaabbabbbaabbba
baabaa -> aababbbaabbabbbaabba
baaa -> aababbbaabbabbbaabbababbbaabbbba

# < a,b | baababbbababbba=a >
baababbbababbba -> a
baababbbababba -> aababbbababbba
baababbbababa -> aababbbababba
baababbbabaa -> aababbbababa
baababbbaa -> aababbbababababbbababbba
baababba -> aababbbababababbbababbbababbbababbba
baababa -> aababbbababababbbababbbababbbababba
baabaa -> aababbbababababbbababbbababbbababa
baaa -> aababbbababababbbababbbababbbababababbbababbba

# < a,b | baababbbabbabba=a >
baababbbabbabba -> a
baababbbabbaba -> aababbbabbabba
baababbbabbaa -> aababbbabbaba
baababbbaba -> aababbbabbabababbbabbabba
baababbbaa -> aababbbabbabababbbabbaba
baababba -> aababbbabbabababbbabbabababbbabbabba
baababa -> aababbbabbabababbbabbabababbbabbaba
baabaa -> aababbbabbabababbbabbabababbbabbaa
baaa -> aababbbabbabababbbabbabababbbaba

# < a,b | baababbbabbbbba=a >
baababbbabbbbba -> a
baababbbabbbba -> aababbbabbbbba
baababbbabbba -> aababbbabbbba
baababbbabba -> aababbbabbba
baababbbaba -> aababbbabba
baababbbaa -> aababbbaba
baababba -> aababbbabababbbabbbbba
baababa -> aababbbabababbbabbbba
baabaa -> aababbbabababbbabbba
baaa -> aababbbabababbbabbbababbbabbbbba

# < a,b | baababbbbaababa=a >
baababbbbaababa -> a
baababbbbaabaa -> aababbbbaababa
baababbbbaaa -> aababbbbaababababbbbaababa

# < a,b | baababbbbabbbba=a >
baababbbbabbbba -> a
baababbbbabbba -> aababbbbabbbba
baababbbbabba -> aababbbbabbba
baababbbbaba -> aababbbbabba
baababbbbaa -> aababbbbaba
baababbba -> aababbbbabababbbbabbbba
baababba -> aababbbbabababbbbabbba
baababa -> aababbbbabababbbbabba
baabaa -> aababbbbabababbbbaba
baaa -> aababbbbabababbbbabababbbbabbbba

# < a,b | baababbbbbbbbba=a >
baababbbbbbbbba -> a
baababbbbbbbba -> aababbbbbbbbba
baababbbbbbba -> aababbbbbbbba
baababbbbbba -> aababbbbbbba
baababbbbba -> aababbbbbba
baababbbba -> aababbbbba
baababbba -> aababbbba
baababba -> aababbba
baababa -> aababba
baabaa -> aababa
baaa -> aababababbbbbbbbba

# < a,b | baabbaaaaaababa=a >
baabbaaaaaababa -> a
baabbaaaaaabaa -> aabbaaaaaababa
baabbaaaaaaa -> aabbaaaaaabababbaaaaaababa

# < a,b | baabbaaaaaabbaa=a >
baabbaaaaaabbaa -> a
baabbaaaaaaba -> abbaaaaaabbaa
baabbaaaaaaa -> abbaaaaaabbaaabbaaaaaabbaa

# < a,b | baabbaaaaababba=a >
baabbaaaaababba -> a
baabbaaaaababa -> aabbaaaaababba
baabbaaaaabaa -> aabbaaaaababa
baabbaaaaaa -> aabbaaaaabababbaaaaababba

# < a,b | baabbaaaaabbaba=a >
baabbaaaaabbaba -> a
baabbaaaaabbaa -> aabbaaaaabbaba
baabbaaaaaba -> aabbaaaaabbababbaaaaabbaba
baabbaaaaaa -> aabbaaaaabbababbaaaaabbaa

# < a,b | baabbaaaaabbbaa=a >
baabbaaaaabbbaa -> a
baabbaaaaabba -> abbaaaaabbbaa
baabbaaaaaba -> abbaaaaabbbaaabbaaaaabbbaa
baabbaaaaaa -> abbaaaaabbbaaabbaaaaabbbaaabbaaaaabbbaa

# < a,b | baabbaaaabababa=a >
baabbaaaabababa -> a
baabbaaaababaa -> aabbaaaabababa
baabbaaaabaa -> aabbaaaababababbaaaabababa
baabbaaaaa -> aabbaaaababababbaaaababababbaaaabababa

# < a,b | baabbaaaababbaa=a >
baabbaaaababbaa -> a
baabbaaaababa -> abbaaaababbaa
baabbaaaabaa -> abbaaaababbaaabbaaaababbaa
baabbaaaaa -> abbaaaababbaaabbaaaababa

# < a,b | baabbaaaababbba=a >
baabbaaaababbba -> a
baabbaaaababba -> aabbaaaababbba
baabbaaaababa -> aabbaaaababba
baabbaaaabaa -> aabbaaaababa
baabbaaaaa -> aabbaaaabababbaaaababbba

# < a,b | baabbaaaabbabaa=a >
baabbaaaabbabaa -> a
baabbaaaabbaa -> abbaaaabbabaa
baabbaaaaba -> abbaaaabbaa
baabbaaaaa -> abbaaaabbaaabbaaaabbabaa

# < a,b | baabbaaaabbabba=a >
baabbaaaabbabba -> a
baabbaaaabbaba -> aabbaaaabbabba
baabbaaaabbaa -> aabbaaaabbaba
baabbaaaaba -> aabbaaaabbababbaaaabbabba
baabbaaaaa -> aabbaaaabbababbaaaabbaba

# < a,b | baabbaaaabbbaba=a >
baabbaaaabbbaba -> a
baabbaaaabbbaa -> aabbaaaabbbaba
baabbaaaabba -> aabbaaaabbbababbaaaabbbaba
baabbaaaaba -> aabbaaaabbbababbaaaabbbaa
baabbaaaaa -> aabbaaaabbbababbaaaabbbaaabbaaaabbbaba

# < a,b | baabbaaaabbbbaa=a >
baabbaaaabbbbaa -> a
baabbaaaabbba -> abbaaaabbbbaa
baabbaaaabba -> abbaaaabbbbaaabbaaaabbbbaa
baabbaaaaba -> abbaaaabbbbaaabbaaaabbbbaaabbaaaabbbbaa
baabbaaaaa -> abbaaaabbbbaaabbaaaabbbbaaabbaaaabbbbaaabbaaaabbbbaa

# < a,b | baabbaaabaababa=a >
baabbaaabaababa -> a
baabbaaabaabaa -> aabbaaabaababa
baabbaaabaaa -> aabbaaabaabababbaaabaababa

# < a,b | baabbaaabaabbaa=a >
baabbaaabaabbaa -> a
baabbaaabaaba -> abbaaabaabbaa
baabbaaaa -> aabaabbaa
baabbaaabaaa -> abbaaabaabbaaabbaaabaabbaa

# < a,b | baabbaaabaabbba=a >
baabbaaabaabbba -> a
baabbaaabaabba -> aabbaaabaabbba
baabbaaabaaba -> aabbaaabaabba
baabbaaaa -> aabbaaabaabbbaaabaabbba
baabbaaabaaa -> aabbaaabaaba

# < a,b | baabbaaabababba=a >
baabbaaabababba -> a
baabbaaabababa -> aabbaaabababba
baabbaaababaa -> aabbaaabababa
baabbaaabaa -> aabbaaababababbaaabababba
baabbaaaa -> aabbaaababababbaaabababbabbaaabababba

# < a,b | baabbaaababbaba=a >
baabbaaababbaba -> a
baabbaaababbaa -> aabbaaababbaba
baabbaaababa -> aabbaaababbababbaaababbaba
baabbaaabaa -> aabbaaababbababbaaababbaa
baabbaaaa -> aabbaaababbababbaaababa

# < a,b | baabbaaababbbaa=a >
baabbaaababbbaa -> a
baabbaaababba -> abbaaababbbaa
baabbaaababa -> abbaaababbbaaabbaaababbbaa
baabbaaabaa -> abbaaababbbaaabbaaababbbaaabbaaababbbaa
baabbaaaa -> abbaaababbbaaabbaaababbbaaabbaaababba

# < a,b | baabbaaababbbba=a >
baabbaaababbbba -> a
baabbaaababbba -> aabbaaababbbba
baabbaaababba -> aabbaaababbba
baabbaaababa -> aabbaaababba
baabbaaabaa -> aabbaaababa
baabbaaaa -> aabbaaabababbaaababbbba

# < a,b | baabbaaabbababa=a >
baabbaaabbababa -> a
baabbaaabbabaa -> aabbaaabbababa
baabbaaabbaa -> aabbaaabbabababbaaabbababa
baabbaaaba -> aabbaaabbabababbaaabbabababbaaabbababa
baabbaaaa -> aabbaaabbabababbaaabbabababbaaabbabaa

# < a,b | baabbaaabbabbaa=a >
baabbaaabbabbaa -> a
baabbaaabbaba -> abbaaabbabbaa
baabbaaabbaa -> abbaaabbabbaaabbaaabbabbaa
baabbaaaba -> abbaaabbabbaaabbaaabbaba
baabbaaaa -> abbaaabbabbaaabbaaabbaa

# < a,b | baabbaaabbabbba=a >
baabbaaabbabbba -> a
baabbaaabbabba -> aabbaaabbabbba
baabbaaabbaba -> aabbaaabbabba
baabbaaabbaa -> aabbaaabbaba
baabbaaaba -> aabbaaabbababbaaabbabbba
baabbaaaa -> aabbaaabbababbaaabbabba

# < a,b | baabbaaabbbabaa=a >
baabbaaabbbabaa -> a
baabbaaabbbaa -> abbaaabbbabaa
baabbaaabba -> abbaaabbbaa
baabbaaaba -> abbaaabbbaaabbaaabbbabaa
baabbaaaa -> abbaaabbbaaabbaaabbbabaaabbaaabbbabaa

# < a,b | baabbaaabbbabba=a >
baabbaaabbbabba -> a
baabbaaabbbaba -> aabbaaabbbabba
baabbaaabbbaa -> aabbaaabbbaba
baabbaaabba -> aabbaaabbbababbaaabbbabba
baabbaaaba -> aabbaaabbbababbaaabbbaba
baabbaaaa -> aabbaaabbbababbaaabbbaa

# < a,b | baabbaaabbbbaba=a >
baabbaaabbbbaba -> a
baabbaaabbbbaa -> aabbaaabbbbaba
baabbaaabbba -> aabbaaabbbbababbaaabbbbaba
baabbaaabba -> aabbaaabbbbababbaaabbbbaa
baabbaaaba -> aabbaaabbbbababbaaabbbbaaabbaaabbbbaba
baabbaaaa -> aabbaaabbbbababbaaabbbbaaabbaaabbbbaa

# < a,b | baabbaaabbbbbaa=a >
baabbaaabbbbbaa -> a
baabbaaabbbba -> abbaaabbbbbaa
baabbaaabbba -> abbaaabbbbbaaabbaaabbbbbaa
baabbaaabba -> abbaaabbbbbaaabbaaabbbbbaaabbaaabbbbbaa
baabbaaaba -> abbaaabbbbbaaabbaaabbbbbaaabbaaabbbbbaaabbaaabbbbbaa
baabbaaaa -> abbaaabbbbbaaabbaaabbbbbaaabbaaabbbbbaaabbaaabbbbbaaabbaaabbbbbaa

# < a,b | baabbaabaaababa=a >
baabbaabaaababa -> a
baabbaabaaabaa -> aabbaabaaababa
baabbaabaaaa -> aabbaabaaabababbaabaaababa

# < a,b | baabbaabaaabbaa=a >
baabbaabaaabbaa -> a
baabbaabaaaba -> abbaabaaabbaa
baabbaabaaaa -> abbaabaaabbaaabbaabaaabbaa

# < a,b | baabbaabaababba=a >
baabbaabaababba -> a
baabbaabaababa -> aabbaabaababba
baabbaabaabaa -> aabbaabaababa
baabbaabaaa -> aabbaabaabababbaabaababba

# < a,b | baabbaabaabbaba=a >
baabbaabaabbaba -> a
baabbaabaabbaa -> aabbaabaabbaba
baabbaabaaba -> aabbaabaabbababbaabaabbaba
baabbaaa -> aabbaabaabbababaabbaba
baabbaabaaa -> aabbaabaabbababbaabaabbaa

# < a,b | baabbaabaabbbaa=a >
baabbaabaabbbaa -> a
baabbaabaabba -> abbaabaabbbaa
baabbaabaaba -> abbaabaabbbaaabbaabaabbbaa
baabbaaa -> abbaabaabbbaaabaabbbaa
baabbaabaaa -> abbaabaabbbaaabbaabaabbbaaabbaabaabbbaa

# < a,b | baabbaabaabbbba=a >
baabbaabaabbbba -> a
baabbaabaabbba -> aabbaabaabbbba
baabbaabaabba -> aabbaabaabbba
baabbaabaaba -> aabbaabaabba
baabbaaa -> aabbaabaabbbaabaabbbba
baabbaabaaa -> aabbaabaaba

# < a,b | baabbaababaabba=a >
baabbaababaabba -> a
baabbaababaaba -> aabbaababaabba
baabbaabaa -> aababaabba
baabbaababaaa -> aabbaababaaba
baabbaaa -> aababaabbabbaababaabba

# < a,b | baabbaababababa=a >
baabbaababababa -> a
baabbaabababaa -> aabbaababababa
baabbaababaa -> aabbaabababababbaababababa
baabbaabaa -> aabbaabababababbaabababababbaababababa
baabbaaa -> aabbaabababababbaabababababbaabababababbaababababa

# < a,b | baabbaabababbaa=a >
baabbaabababbaa -> a
baabbaabababa -> abbaabababbaa
baabbaababaa -> abbaabababbaaabbaabababbaa
baabbaabaa -> abbaabababbaaabbaabababa
baabbaaa -> abbaabababbaaabbaababababbaabababbaa

# < a,b | baabbaabababbba=a >
baabbaabababbba -> a
baabbaabababba -> aabbaabababbba
baabbaabababa -> aabbaabababba
baabbaababaa -> aabbaabababa
baabbaabaa -> aabbaababababbaabababbba
baabbaaa -> aabbaababababbaabababbbabbaabababbba

# < a,b | baabbaababbabaa=a >
baabbaababbabaa -> a
baabbaababbaa -> abbaababbabaa
baabbaababa -> abbaababbaa
baabbaabaa -> abbaababbaaabbaababbabaa
baabbaaa -> abbaababbaaabbaababbaa

# < a,b | baabbaababbabba=a >
baabbaababbabba -> a
baabbaababbaba -> aabbaababbabba
baabbaababbaa -> aabbaababbaba
baabbaababa -> aabbaababbababbaababbabba
baabbaabaa -> aabbaababbababbaababbaba
baabbaaa -> aabbaababbababbaababbababbaababbabba

# < a,b | baabbaababbbaba=a >
baabbaababbbaba -> a
baabbaababbbaa -> aabbaababbbaba
baabbaababba -> aabbaababbbababbaababbbaba
baabbaababa -> aabbaababbbababbaababbbaa
baabbaabaa -> aabbaababbbababbaababbbaaabbaababbbaba
baabbaaa -> aabbaababbbababbaababbbaaabbaababbbababbaababbbaba

# < a,b | baabbaababbbbaa=a >
baabbaababbbbaa -> a
baabbaababbba -> abbaababbbbaa
baabbaababba -> abbaababbbbaaabbaababbbbaa
baabbaababa -> abbaababbbbaaabbaababbbbaaabbaababbbbaa
baabbaabaa -> abbaababbbbaaabbaababbbbaaabbaababbbbaaabbaababbbbaa
baabbaaa -> abbaababbbbaaabbaababbbbaaabbaababbbbaaabbaababbba

# < a,b | baabbaababbbbba=a >
baabbaababbbbba -> a
baabbaababbbba -> aabbaababbbbba
baabbaababbba -> aabbaababbbba
baabbaababba -> aabbaababbba
baabbaababa -> aabbaababba
baabbaabaa -> aabbaababa
baabbaaa -> aabbaabababbaababbbbba

# < a,b | baabbaabbaababa=a >
baabbaabbaababa -> a
baabbaabbaabaa -> aabbaabbaababa
baabbaabbaaa -> aabbaabbaabababbaabbaababa

# < a,b | baabbaabbaabbba=a >
baabbaabbaabbba -> a
baabbaabbaabba -> aabbaabbaabbba
baaba -> aabbaabbaabbbaabbba
baaa -> aabbaabbaabbbaabba

# < a,b | baabbaabbababba=a >
baabbaabbababba -> a
baabbaabbababa -> aabbaabbababba
baabbaabbabaa -> aabbaabbababa
baabbaabbaa -> aabbaabbabababbaabbababba
baaba -> aabbaabbabababbaabbababbabbababba
baaa -> aabbaabbabababbaabbababbabbababa

# < a,b | baabbaabbabbaba=a >
baabbaabbabbaba -> a
baabbaabbabbaa -> aabbaabbabbaba
baabbaabbaba -> aabbaabbabbababbaabbabbaba
baabbaabbaa -> aabbaabbabbababbaabbabbaa
baaba -> aabbaabbabbababbaabbabbaabbabbaba
baaa -> aabbaabbabbababbaabbabbaabbabbaa

# < a,b | baabbaabbabbbba=a >
baabbaabbabbbba -> a
baabbaabbabbba -> aabbaabbabbbba
baabbaabbabba -> aabbaabbabbba
baabbaabbaba -> aabbaabbabba
baabbaabbaa -> aabbaabbaba
baaba -> aabbaabbababbabbbba
baaa -> aabbaabbababbabbba

# < a,b | baabbaabbbababa=a >
baabbaabbbababa -> a
baabbaabbbabaa -> aabbaabbbababa
baabbaabbbaa -> aabbaabbbabababbaabbbababa
baabbaabba -> aabbaabbbabababbaabbbabababbaabbbababa
baaba -> aabbaabbbabababbaabbbabababbaabbbababaabbbababa
baaa -> aabbaabbbabababbaabbbabababbaabbbababaabbbabaa

# < a,b | baabbaabbbabbba=a >
baabbaabbbabbba -> a
baabbaabbbabba -> aabbaabbbabbba
baabbaabbbaba -> aabbaabbbabba
baabbaabbbaa -> aabbaabbbaba
baabbaabba -> aabbaabbbababbaabbbabbba
baaba -> aabbaabbbababbaabbbabbbaabbbabbba
baaa -> aabbaabbbababbaabbbabbbaabbbabba

# < a,b | baabbaabbbbabba=a >
baabbaabbbbabba -> a
baabbaabbbbaba -> aabbaabbbbabba
baabbaabbbbaa -> aabbaabbbbaba
baabbaabbba -> aabbaabbbbababbaabbbbabba
baabbaabba -> aabbaabbbbababbaabbbbaba
baaba -> aabbaabbbbababbaabbbbabaabbbbabba
baaa -> aabbaabbbbababbaabbbbabaabbbbaba

# < a,b | baabbaabbbbbbba=a >
baabbaabbbbbbba -> a
baabbaabbbbbba -> aabbaabbbbbbba
baabbaabbbbba -> aabbaabbbbbba
baabbaabbbba -> aabbaabbbbba
baabbaabbba -> aabbaabbbba
baabbaabba -> aabbaabbba
baaba -> aabbaabbbaabbbbbbba
baaa -> aabbaabbbaabbbbbba

# < a,b | baabbabaaaababa=a >
baabbabaaaababa -> a
baabbabaaaabaa -> aabbabaaaababa
baabbabaaaaa -> aabbabaaaabababbabaaaababa

# < a,b | baabbabaaaabbaa=a >
baabbabaaaabbaa -> a
baabbabaaaaba -> abbabaaaabbaa
baabbabaaaaa -> abbabaaaabbaaabbabaaaabbaa

# < a,b | baabbabaaababba=a >
baabbabaaababba -> a
baabbabaaababa -> aabbabaaababba
baabbabaaabaa -> aabbabaaababa
baabbabaaaa -> aabbabaaabababbabaaababba

# < a,b | baabbabaaabbaba=a >
baabbabaaabbaba -> a
baabbabaaabbaa -> aabbabaaabbaba
baabbabaaaba -> aabbabaaabbababbabaaabbaba
baabbabaaaa -> aabbabaaabbababbabaaabbaa

# < a,b | baabbabaaabbbaa=a >
baabbabaaabbbaa -> a
baabbabaaabba -> abbabaaabbbaa
baabbabaaaba -> abbabaaabbbaaabbabaaabbbaa
baabbabaaaa -> abbabaaabbbaaabbabaaabbbaaabbabaaabbbaa

# < a,b | baabbabaabababa=a >
baabbabaabababa -> a
baabbabaababaa -> aabbabaabababa
baabbabaabaa -> aabbabaababababbabaabababa
baabbabaaa -> aabbabaababababbabaababababbabaabababa

# < a,b | baabbabaababbaa=a >
baabbabaababbaa -> a
baabbabaababa -> abbabaababbaa
baabbabaabaa -> abbabaababbaaabbabaababbaa
baabbabaaa -> abbabaababbaaabbabaababa

# < a,b | baabbabaababbba=a >
baabbabaababbba -> a
baabbabaababba -> aabbabaababbba
baabbabaababa -> aabbabaababba
baabbabaabaa -> aabbabaababa
baabbabaaa -> aabbabaabababbabaababbba

# < a,b | baabbabaabbabba=a >
baabbabaabbabba -> a
baabbabaabbaba -> aabbabaabbabba
baabbaa -> aabbabaabbabbaabbabba
baaba -> aabbabaabbabbaabbabbabbabaabbabba
baaa -> aabbabaabbabbaabbabbabbabaabbaba

# < a,b | baabbabaabbbaba=a >
baabbabaabbbaba -> a
baabbabaabbbaa -> aabbabaabbbaba
baabbabaabba -> aabbabaabbbababbabaabbbaba
baabbaa -> aabbabaabbbababbabaabbbababaabbbaba
baaba -> aabbabaabbbababbabaabbbababaabbbababbabaabbbaba
baaa -> aabbabaabbbababbabaabbbababaabbbababbabaabbbaa

# < a,b | baabbabaabbbbba=a >
baabbabaabbbbba -> a
baabbabaabbbba -> aabbabaabbbbba
baabbabaabbba -> aabbabaabbbba
baabbabaabba -> aabbabaabbba
baabbaa -> aabbabaabbbabaabbbbba
baaba -> aabbabaabbbabaabbbbbabbabaabbbbba
baaa -> aabbabaabbbabaabbbbbabbabaabbbba

# < a,b | baabbababaababa=a >
baabbababaababa -> a
baabbababaabaa -> aabbababaababa
baabbababaaa -> aabbababaabababbababaababa

# < a,b | baabbababaabbaa=a >
baabbababaabbaa -> a
baabbababaaba -> abbababaabbaa
baabbababaaa -> abbababaabbaaabbababaabbaa

# < a,b | baabbababaabbba=a >
baabbababaabbba -> a
baabbababaabba -> aabbababaabbba
baabbabaa -> aabbababaabbbababaabbba
baabbaa -> aabbababaabbbababaabbbabbababaabbba
baaba -> aabbababaabbbababaabbbabbababaabbbabbababaabbba
baaa -> aabbababaabbbababaabbbabbababaabbbabbababaabba

# < a,b | baabbababababba=a >
baabbababababba -> a
baabbababababa -> aabbababababba
baabbabababaa -> aabbababababa
baabbababaa -> aabbabababababbababababba
baabbabaa -> aabbabababababbababababbabbababababba
baabbaa -> aabbabababababbababababbabbababababbabbababababba
baaba -> aabbabababababbababababbabbababababbabbababababbabbababababba
baaa -> aabbabababababbababababbabbababababbabbababababbabbababababa

# < a,b | baabbabababbaba=a >
baabbabababbaba -> a
baabbabababbaa -> aabbabababbaba
baabbabababa -> aabbabababbababbabababbaba
baabbababaa -> aabbabababbababbabababbaa
baabbabaa -> aabbabababbababbabababa
baabbaa -> aabbabababbababbababababbabababbaba
baaba -> aabbabababbababbababababbabababbababbabababbaba
baaa -> aabbabababbababbababababbabababbababbabababbaa

# < a,b | baabbabababbbba=a >
baabbabababbbba -> a
baabbabababbba -> aabbabababbbba
baabbabababba -> aabbabababbba
baabbabababa -> aabbabababba
baabbababaa -> aabbabababa
baabbabaa -> aabbababababbabababbbba
baabbaa -> aabbababababbabababbbbabbabababbbba
baaba -> aabbababababbabababbbbabbabababbbbabbabababbbba
baaa -> aabbababababbabababbbbabbabababbbbabbabababbba

# < a,b | baabbababbababa=a >
baabbababbababa -> a
baabbababbabaa -> aabbababbababa
baabbababbaa -> aabbababbabababbababbababa
baabbababa -> aabbababbabababbababbabababbababbababa
baabbabaa -> aabbababbabababbababbabababbababbabaa
baabbaa -> aabbababbabababbababbabababbababbaa
baaba -> aabbababbabababbababbabababbababa
baaa -> aabbababbabababbababbabababbabaa

# < a,b | baabbababbabbba=a >
baabbababbabbba -> a
baabbababbabba -> aabbababbabbba
baabbababbaba -> aabbababbabba
baabbababbaa -> aabbababbaba
baabbababa -> aabbababbababbababbabbba
baabbabaa -> aabbababbababbababbabba
baabbaa -> aabbababbababbababbabbabbababbabbba
baaba -> aabbababbababbababbabbabbababbabbbabbababbabbba
baaa -> aabbababbababbababbabbabbababbabbbabbababbabba

# < a,b | baabbababbbabba=a >
baabbababbbabba -> a
baabbababbbaba -> aabbababbbabba
baabbababbbaa -> aabbababbbaba
baabbababba -> aabbababbbababbababbbabba
baabbababa -> aabbababbbababbababbbaba
baabbabaa -> aabbababbbababbababbbaa
baabbaa -> aabbababbbababbababba
baaba -> aabbababbbababbababbabbababbbabba
baaa -> aabbababbbababbababbabbababbbaba

# < a,b | baabbababbbbbba=a >
baabbababbbbbba -> a
baabbababbbbba -> aabbababbbbbba
baabbababbbba -> aabbababbbbba
baabbababbba -> aabbababbbba
baabbababba -> aabbababbba
baabbababa -> aabbababba
baabbabaa -> aabbababa
baabbaa -> aabbabababbababbbbbba
baaba -> aabbabababbababbbbbbabbababbbbbba
baaa -> aabbabababbababbbbbbabbababbbbba

# < a,b | baabbabbaaababa=a >
baabbabbaaababa -> a
baabbabbaaabaa -> aabbabbaaababa
baabbabbaaaa -> aabbabbaaabababbabbaaababa

# < a,b | baabbabbaaabbaa=a >
baabbabbaaabbaa -> a
baabbabbaaaba -> abbabbaaabbaa
baabbabbaaaa -> abbabbaaabbaaabbabbaaabbaa

# < a,b | baabbabbaababba=a >
baabbabbaababba -> a
baabbabbaababa -> aabbabbaababba
baabbabbaabaa -> aabbabbaababa
baabbabbaaa -> aabbabbaabababbabbaababba

# < a,b | baabbabbaabbaba=a >
baabbabbaabbaba -> a
baabbabbaabbaa -> aabbabbaabbaba
baabbabbaaba -> aabbabbaabbababbabbaabbaba
baabbabbaaa -> aabbabbaabbababbabbaabbaa

# < a,b | baabbabbaabbbba=a >
baabbabbaabbbba -> a
baabbabbaabbba -> aabbabbaabbbba
baabbabbaabba -> aabbabbaabbba
baabbaba -> aabbabbaabbbabbaabbbba
baabbaa -> aabbabbaabbbabbaabbba
baaba -> aabbabbaabbbabbaabbbabbabbaabbbba
baaa -> aabbabbaabbbabbaabbbabbabbaabbba

# < a,b | baabbabbababbba=a >
baabbabbababbba -> a
baabbabbababba -> aabbabbababbba
baabbabbababa -> aabbabbababba
baabbabbabaa -> aabbabbababa
baabbabbaa -> aabbabbabababbabbababbba
baabbaba -> aabbabbabababbabbababbbabbabbababbba
baabbaa -> aabbabbabababbabbababbbabbabbababba
baaba -> aabbabbabababbabbababbbabbabbababbabbabbababbba
baaa -> aabbabbabababbabbababbbabbabbababbabbabbababba

# < a,b | baabbabbabbabba=a >
baabbabbabbabba -> a
baabbabbabbaba -> aabbabbabbabba
baabbabbabbaa -> aabbabbabbaba
baabbabbaba -> aabbabbabbababbabbabbabba
baabbabbaa -> aabbabbabbababbabbabbaba
baabbaba -> aabbabbabbababbabbabbababbabbabbabba
baabbaa -> aabbabbabbababbabbabbababbabbabbaba
baaba -> aabbabbabbababbabbabbababbabbabbababbabbabbabba
baaa -> aabbabbabbababbabbabbababbabbabbababbabbabbaba

# < a,b | baabbabbabbbbba=a >
baabbabbabbbbba -> a
baabbabbabbbba -> aabbabbabbbbba
baabbabbabbba -> aabbabbabbbba
baabbabbabba -> aabbabbabbba
baabbabbaba -> aabbabbabba
baabbabbaa -> aabbabbaba
baabbaba -> aabbabbababbabbabbbbba
baabbaa -> aabbabbababbabbabbbba
baaba -> aabbabbababbabbabbbbabbabbabbbbba
baaa -> aabbabbababbabbabbbbabbabbabbbba

# < a,b | baabbabbbaababa=a >
baabbabbbaababa -> a
baabbabbbaabaa -> aabbabbbaababa
baabbabbbaaa -> aabbabbbaabababbabbbaababa

# < a,b | baabbabbbaabbaa=a >
baabbabbbaabbaa -> a
baabbabbbaaba -> abbabbbaabbaa
baabbabbbaaa -> abbabbbaabbaaabbabbbaabbaa

# < a,b | baabbabbbabbbba=a >
baabbabbbabbbba -> a
baabbabbbabbba -> aabbabbbabbbba
baabbabbbabba -> aabbabbbabbba
baabbabbbaba -> aabbabbbabba
baabbabbbaa -> aabbabbbaba
baabbabba -> aabbabbbababbabbbabbbba
baabbaba -> aabbabbbababbabbbabbba
baabbaa -> aabbabbbababbabbbabba
baaba -> aabbabbbababbabbbabbabbabbbabbbba
baaa -> aabbabbbababbabbbabbabbabbbabbba

# < a,b | baabbabbbbabbba=a >
baabbabbbbabbba -> a
baabbabbbbabba -> aabbabbbbabbba
baabbabbbbaba -> aabbabbbbabba
baabbabbbbaa -> aabbabbbbaba
baabbabbba -> aabbabbbbababbabbbbabbba
baabbabba -> aabbabbbbababbabbbbabba
baabbaba -> aabbabbbbababbabbbbaba
baabbaa -> aabbabbbbababbabbbbaa
baaba -> aabbabbbbababbabbba
baaa -> aabbabbbbababbabba

# < a,b | baabbabbbbbbbba=a >
baabbabbbbbbbba -> a
baabbabbbbbbba -> aabbabbbbbbbba
baabbabbbbbba -> aabbabbbbbbba
baabbabbbbba -> aabbabbbbbba
baabbabbbba -> aabbabbbbba
baabbabbba -> aabbabbbba
baabbabba -> aabbabbba
baabbaba -> aabbabba
baabbaa -> aabbaba
baaba -> aabbababbabbbbbbbba
baaa -> aabbababbabbbbbbba

# < a,b | baabbbaaaaababa=a >
baabbbaaaaababa -> a
baabbbaaaaabaa -> aabbbaaaaababa
baabbbaaaaaa -> aabbbaaaaabababbbaaaaababa

# < a,b | baabbbaaaaabbaa=a >
baabbbaaaaabbaa -> a
baabbbaaaaaba -> abbbaaaaabbaa
baabbbaaaaaa -> abbbaaaaabbaaabbbaaaaabbaa

# < a,b | baabbbaaaababba=a >
baabbbaaaababba -> a
baabbbaaaababa -> aabbbaaaababba
baabbbaaaabaa -> aabbbaaaababa
baabbbaaaaa -> aabbbaaaabababbbaaaababba

# < a,b | baabbbaaaabbaba=a >
baabbbaaaabbaba -> a
baabbbaaaabbaa -> aabbbaaaabbaba
baabbbaaaaba -> aabbbaaaabbababbbaaaabbaba
baabbbaaaaa -> aabbbaaaabbababbbaaaabbaa

# < a,b | baabbbaaaabbbaa=a >
baabbbaaaabbbaa -> a
baabbbaaaabba -> abbbaaaabbbaa
baabbbaaaaba -> abbbaaaabbbaaabbbaaaabbbaa
baabbbaaaaa -> abbbaaaabbbaaabbbaaaabbbaaabbbaaaabbbaa

# < a,b | baabbbaaabababa=a >
baabbbaaabababa -> a
baabbbaaababaa -> aabbbaaabababa
baabbbaaabaa -> aabbbaaababababbbaaabababa
baabbbaaaa -> aabbbaaababababbbaaababababbbaaabababa

# < a,b | baabbbaaababbaa=a >
baabbbaaababbaa -> a
baabbbaaababa -> abbbaaababbaa
baabbbaaabaa -> abbbaaababbaaabbbaaababbaa
baabbbaaaa -> abbbaaababbaaabbbaaababa

# < a,b | baabbbaaababbba=a >
baabbbaaababbba -> a
baabbbaaababba -> aabbbaaababbba
baabbbaaababa -> aabbbaaababba
baabbbaaabaa -> aabbbaaababa
baabbbaaaa -> aabbbaaabababbbaaababbba

# < a,b | baabbbaaabbabaa=a >
baabbbaaabbabaa -> a
baabbbaaabbaa -> abbbaaabbabaa
baabbbaaaba -> abbbaaabbaa
baabbbaaaa -> abbbaaabbaaabbbaaabbabaa

# < a,b | baabbbaaabbabba=a >
baabbbaaabbabba -> a
baabbbaaabbaba -> aabbbaaabbabba
baabbbaaabbaa -> aabbbaaabbaba
baabbbaaaba -> aabbbaaabbababbbaaabbabba
baabbbaaaa -> aabbbaaabbababbbaaabbaba

# < a,b | baabbbaaabbbaba=a >
baabbbaaabbbaba -> a
baabbbaaabbbaa -> aabbbaaabbbaba
baabbbaaabba -> aabbbaaabbbababbbaaabbbaba
baabbbaaaba -> aabbbaaabbbababbbaaabbbaa
baabbbaaaa -> aabbbaaabbbababbbaaabbbaaabbbaaabbbaba

# < a,b | baabbbaaabbbbaa=a >
baabbbaaabbbbaa -> a
baabbbaaabbba -> abbbaaabbbbaa
baabbbaaabba -> abbbaaabbbbaaabbbaaabbbbaa
baabbbaaaba -> abbbaaabbbbaaabbbaaabbbbaaabbbaaabbbbaa
baabbbaaaa -> abbbaaabbbbaaabbbaaabbbbaaabbbaaabbbbaaabbbaaabbbbaa

# < a,b | baabbbaabaababa=a >
baabbbaabaababa -> a
baabbbaabaabaa -> aabbbaabaababa
baabbbaabaaa -> aabbbaabaabababbbaabaababa

# < a,b | baabbbaabaabbaa=a >
baabbbaabaabbaa -> a
baabbbaabaaba -> abbbaabaabbaa
baabbbaabaaa -> abbbaabaabbaaabbbaabaabbaa

# < a,b | baabbbaabababba=a >
baabbbaabababba -> a
baabbbaabababa -> aabbbaabababba
baabbbaababaa -> aabbbaabababa
baabbbaabaa -> aabbbaababababbbaabababba
baabbbaaa -> aabbbaababababbbaabababbabbbaabababba

# < a,b | baabbbaababbaba=a >
baabbbaababbaba -> a
baabbbaababbaa -> aabbbaababbaba
baabbbaababa -> aabbbaababbababbbaababbaba
baabbbaabaa -> aabbbaababbababbbaababbaa
baabbbaaa -> aabbbaababbababbbaababa

# < a,b | baabbbaababbbaa=a >
baabbbaababbbaa -> a
baabbbaababba -> abbbaababbbaa
baabbbaababa -> abbbaababbbaaabbbaababbbaa
baabbbaabaa -> abbbaababbbaaabbbaababbbaaabbbaababbbaa
baabbbaaa -> abbbaababbbaaabbbaababbbaaabbbaababba

# < a,b | baabbbaababbbba=a >
baabbbaababbbba -> a
baabbbaababbba -> aabbbaababbbba
baabbbaababba -> aabbbaababbba
baabbbaababa -> aabbbaababba
baabbbaabaa -> aabbbaababa
baabbbaaa -> aabbbaabababbbaababbbba

# < a,b | baabbbaabbababa=a >
baabbbaabbababa -> a
baabbbaabbabaa -> aabbbaabbababa
baabbbaabbaa -> aabbbaabbabababbbaabbababa
baabbbaaba -> aabbbaabbabababbbaabbabababbbaabbababa
baabbbaaa -> aabbbaabbabababbbaabbabababbbaabbabaa

# < a,b | baabbbaabbabbaa=a >
baabbbaabbabbaa -> a
baabbbaabbaba -> abbbaabbabbaa
baabbbaabbaa -> abbbaabbabbaaabbbaabbabbaa
baabbbaaba -> abbbaabbabbaaabbbaabbaba
baabbbaaa -> abbbaabbabbaaabbbaabbaa

# < a,b | baabbbaabbabbba=a >
baabbbaabbabbba -> a
baabbbaabbabba -> aabbbaabbabbba
baabbbaabbaba -> aabbbaabbabba
baabbbaabbaa -> aabbbaabbaba
baabbbaaba -> aabbbaabbababbbaabbabbba
baabbbaaa -> aabbbaabbababbbaabbabba

# < a,b | baabbbaabbbabba=a >
baabbbaabbbabba -> a
baabbbaabbbaba -> aabbbaabbbabba
baabbbaabbbaa -> aabbbaabbbaba
baabba -> aabbbaabbbababbbabba
baaba -> aabbbaabbbababbbaba
baaa -> aabbbaabbbababbbaa

# < a,b | baabbbaabbbbbba=a >
baabbbaabbbbbba -> a
baabbbaabbbbba -> aabbbaabbbbbba
baabbbaabbbba -> aabbbaabbbbba
baabbbaabbba -> aabbbaabbbba
baabba -> aabbbaabbbbaabbbbbba
baaba -> aabbbaabbbbaabbbbba
baaa -> aabbbaabbbbaabbbba

# < a,b | baabbbabaaababa=a >
baabbbabaaababa -> a
baabbbabaaabaa -> aabbbabaaababa
baabbbabaaaa -> aabbbabaaabababbbabaaababa

# < a,b | baabbbabaaabbaa=a >
baabbbabaaabbaa -> a
baabbbabaaaba -> abbbabaaabbaa
baabbbabaaaa -> abbbabaaabbaaabbbabaaabbaa

# < a,b | baabbbabaababba=a >
baabbbabaababba -> a
baabbbabaababa -> aabbbabaababba
baabbbabaabaa -> aabbbabaababa
baabbbabaaa -> aabbbabaabababbbabaababba

# < a,b | baabbbabaabbaba=a >
baabbbabaabbaba -> a
baabbbabaabbaa -> aabbbabaabbaba
baabbbabaaba -> aabbbabaabbababbbabaabbaba
baabbbabaaa -> aabbbabaabbababbbabaabbaa

# < a,b | baabbbabaabbbaa=a >
baabbbabaabbbaa -> a
baabbbabaabba -> abbbabaabbbaa
baabbbabaaba -> abbbabaabbbaaabbbabaabbbaa
baabbbabaaa -> abbbabaabbbaaabbbabaabbbaaabbbabaabbbaa

# < a,b | baabbbabababbba=a >
baabbbabababbba -> a
baabbbabababba -> aabbbabababbba
baabbbabababa -> aabbbabababba
baabbbababaa -> aabbbabababa
baabbbabaa -> aabbbababababbbabababbba
baabbbaa -> aabbbababababbbabababbbabbbabababbba
baabba -> aabbbababababbbabababbbabbbabababbbabbbabababbba
baaba -> aabbbababababbbabababbbabbbabababbbabbbabababba
baaa -> aabbbababababbbabababbbabbbabababbbabbbabababa

# < a,b | baabbbababbabba=a >
baabbbababbabba -> a
baabbbababbaba -> aabbbababbabba
baabbbababbaa -> aabbbababbaba
baabbbababa -> aabbbababbababbbababbabba
baabbbabaa -> aabbbababbababbbababbaba
baabbbaa -> aabbbababbababbbababbababbbababbabba
baabba -> aabbbababbababbbababbababbbababbabbabbbababbabba
baaba -> aabbbababbababbbababbababbbababbabbabbbababbaba
baaa -> aabbbababbababbbababbababbbababbabbabbbababbaa

# < a,b | baabbbababbbbba=a >
baabbbababbbbba -> a
baabbbababbbba -> aabbbababbbbba
baabbbababbba -> aabbbababbbba
baabbbababba -> aabbbababbba
baabbbababa -> aabbbababba
baabbbabaa -> aabbbababa
baabbbaa -> aabbbabababbbababbbbba
baabba -> aabbbabababbbababbbbbabbbababbbbba
baaba -> aabbbabababbbababbbbbabbbababbbba
baaa -> aabbbabababbbababbbbbabbbababbba

# < a,b | baabbbabbaababa=a >
baabbbabbaababa -> a
baabbbabbaabaa -> aabbbabbaababa
baabbbabbaaa -> aabbbabbaabababbbabbaababa

# < a,b | baabbbabbaabbaa=a >
baabbbabbaabbaa -> a
baabbbabbaaba -> abbbabbaabbaa
baabbbabbaaa -> abbbabbaabbaaabbbabbaabbaa

# < a,b | baabbbabbababba=a >
baabbbabbababba -> a
baabbbabbababa -> aabbbabbababba
baabbbabbabaa -> aabbbabbababa
baabbbabbaa -> aabbbabbabababbbabbababba
baabbbaba -> aabbbabbabababbbabbababbabbbabbababba
baabbbaa -> aabbbabbabababbbabbababbabbbabbababa
baabba -> aabbbabbabababbbabbababbabbbabbabababbbabbababba
baaba -> aabbbabbabababbbabbababbabbbabbabababbbabbababa
baaa -> aabbbabbabababbbabbababbabbbabbabababbbabbabaa

# < a,b | baabbbabbabbbba=a >
baabbbabbabbbba -> a
baabbbabbabbba -> aabbbabbabbbba
baabbbabbabba -> aabbbabbabbba
baabbbabbaba -> aabbbabbabba
baabbbabbaa -> aabbbabbaba
baabbbaba -> aabbbabbababbbabbabbbba
baabbbaa -> aabbbabbababbbabbabbba
baabba -> aabbbabbababbbabbabbbabbbabbabbbba
baaba -> aabbbabbababbbabbabbbabbbabbabbba
baaa -> aabbbabbababbbabbabbbabbbabbabba

# < a,b | baabbbabbbabbba=a >
baabbbabbbabbba -> a
baabbbabbbabba -> aabbbabbbabbba
baabbbabbbaba -> aabbbabbbabba
baabbbabbbaa -> aabbbabbbaba
baabbbabba -> aabbbabbbababbbabbbabbba
baabbbaba -> aabbbabbbababbbabbbabba
baabbbaa -> aabbbabbbababbbabbbaba
baabba -> aabbbabbbababbbabbbababbbabbbabbba
baaba -> aabbbabbbababbbabbbababbbabbbabba
baaa -> aabbbabbbababbbabbbababbbabbbaba

# < a,b | baabbbabbbbbbba=a >
baabbbabbbbbbba -> a
baabbbabbbbbba -> aabbbabbbbbbba
baabbbabbbbba -> aabbbabbbbbba
baabbbabbbba -> aabbbabbbbba
baabbbabbba -> aabbbabbbba
baabbbabba -> aabbbabbba
baabbbaba -> aabbbabba
baabbbaa -> aabbbaba
baabba -> aabbbababbbabbbbbbba
baaba -> aabbbababbbabbbbbba
baaa -> aabbbababbbabbbbba

# < a,b | baabbbbaaaababa=a >
baabbbbaaaababa -> a
baabbbbaaaabaa -> aabbbbaaaababa
baabbbbaaaaa -> aabbbbaaaabababbbbaaaababa

# < a,b | baabbbbaaaabbaa=a >
baabbbbaaaabbaa -> a
baabbbbaaaaba -> abbbbaaaabbaa
baabbbbaaaaa -> abbbbaaaabbaaabbbbaaaabbaa

# < a,b | baabbbbaaababba=a >
baabbbbaaababba -> a
baabbbbaaababa -> aabbbbaaababba
baabbbbaaabaa -> aabbbbaaababa
baabbbbaaaa -> aabbbbaaabababbbbaaababba

# < a,b | baabbbbaaabbaba=a >
baabbbbaaabbaba -> a
baabbbbaaabbaa -> aabbbbaaabbaba
baabbbbaaaba -> aabbbbaaabbababbbbaaabbaba
baabbbbaaaa -> aabbbbaaabbababbbbaaabbaa

# < a,b | baabbbbaaabbbaa=a >
baabbbbaaabbbaa -> a
baabbbbaaabba -> abbbbaaabbbaa
baabbbbaaaba -> abbbbaaabbbaaabbbbaaabbbaa
baabbbbaaaa -> abbbbaaabbbaaabbbbaaabbbaaabbbbaaabbbaa

# < a,b | baabbbbaabababa=a >
baabbbbaabababa -> a
baabbbbaababaa -> aabbbbaabababa
baabbbbaabaa -> aabbbbaababababbbbaabababa
baabbbbaaa -> aabbbbaababababbbbaababababbbbaabababa

# < a,b | baabbbbaababbaa=a >
baabbbbaababbaa -> a
baabbbbaababa -> abbbbaababbaa
baabbbbaabaa -> abbbbaababbaaabbbbaababbaa
baabbbbaaa -> abbbbaababbaaabbbbaababa

# < a,b | baabbbbaababbba=a >
baabbbbaababbba -> a
baabbbbaababba -> aabbbbaababbba
baabbbbaababa -> aabbbbaababba
baabbbbaabaa -> aabbbbaababa
baabbbbaaa -> aabbbbaabababbbbaababbba

# < a,b | baabbbbaabbabaa=a >
baabbbbaabbabaa -> a
baabbbbaabbaa -> abbbbaabbabaa
baabbbbaaba -> abbbbaabbaa
baabbbbaaa -> abbbbaabbaaabbbbaabbabaa

# < a,b | baabbbbaabbabba=a >
baabbbbaabbabba -> a
baabbbbaabbaba -> aabbbbaabbabba
baabbbbaabbaa -> aabbbbaabbaba
baabbbbaaba -> aabbbbaabbababbbbaabbabba
baabbbbaaa -> aabbbbaabbababbbbaabbaba

# < a,b | baabbbbaabbbaba=a >
baabbbbaabbbaba -> a
baabbbbaabbbaa -> aabbbbaabbbaba
baabbbbaabba -> aabbbbaabbbababbbbaabbbaba
baabbbbaaba -> aabbbbaabbbababbbbaabbbaa
baabbbbaaa -> aabbbbaabbbababbbbaabbbaaabbbbaabbbaba

# < a,b | baabbbbaabbbbba=a >
baabbbbaabbbbba -> a
baabbbbaabbbba -> aabbbbaabbbbba
baabbba -> aabbbbaabbbbbaabbbbba
baabba -> aabbbbaabbbbbaabbbba
baaba -> aabbaabbbbbaabbbbba
baaa -> aabbaabbbbbaabbbba

# < a,b | baabbbbabaababa=a >
baabbbbabaababa -> a
baabbbbabaabaa -> aabbbbabaababa
baabbbbabaaa -> aabbbbabaabababbbbabaababa

# < a,b | baabbbbabaabbaa=a >
baabbbbabaabbaa -> a
baabbbbabaaba -> abbbbabaabbaa
baabbbbabaaa -> abbbbabaabbaaabbbbabaabbaa

# < a,b | baabbbbababbbba=a >
baabbbbababbbba -> a
baabbbbababbba -> aabbbbababbbba
baabbbbababba -> aabbbbababbba
baabbbbababa -> aabbbbababba
baabbbbabaa -> aabbbbababa
baabbbbaa -> aabbbbabababbbbababbbba
baabbba -> aabbbbabababbbbababbbbabbbbababbbba
baabba -> aabbbbabababbbbababbbbabbbbababbba
baaba -> aabbbbabababbbbababbbbabbbbababba
baaa -> aabbbbabababbbbababbbbabbbbababa

# < a,b | baabbbbabbabbba=a >
baabbbbabbabbba -> a
baabbbbabbabba -> aabbbbabbabbba
baabbbbabbaba -> aabbbbabbabba
baabbbbabbaa -> aabbbbabbaba
baabbbbaba -> aabbbbabbababbbbabbabbba
baabbbbaa -> aabbbbabbababbbbabbabba
baabbba -> aabbbbabbababbbbabbabbabbbbabbabbba
baabba -> aabbbbabbababbbbabbabbabbbbabbabba
baaba -> aabbbbabbababbbbabbabbabbbbabbaba
baaa -> aabbbbabbababbbbabbabbabbbbabbaa

# < a,b | baabbbbabbbbbba=a >
baabbbbabbbbbba -> a
baabbbbabbbbba -> aabbbbabbbbbba
baabbbbabbbba -> aabbbbabbbbba
baabbbbabbba -> aabbbbabbbba
baabbbbabba -> aabbbbabbba
baabbbbaba -> aabbbbabba
baabbbbaa -> aabbbbaba
baabbba -> aabbbbababbbbabbbbbba
baabba -> aabbbbababbbbabbbbba
baaba -> aabbbbababbbbabbbba
baaa -> aabbbbababbbbabbba

# < a,b | baabbbbbaaababa=a >
baabbbbbaaababa -> a
baabbbbbaaabaa -> aabbbbbaaababa
baabbbbbaaaa -> aabbbbbaaabababbbbbaaababa

# < a,b | baabbbbbaaabbaa=a >
baabbbbbaaabbaa -> a
baabbbbbaaaba -> abbbbbaaabbaa
baabbbbbaaaa -> abbbbbaaabbaaabbbbbaaabbaa

# < a,b | baabbbbbaababba=a >
baabbbbbaababba -> a
baabbbbbaababa -> aabbbbbaababba
baabbbbbaabaa -> aabbbbbaababa
baabbbbbaaa -> aabbbbbaabababbbbbaababba

# < a,b | baabbbbbaabbaba=a >
baabbbbbaabbaba -> a
baabbbbbaabbaa -> aabbbbbaabbaba
baabbbbbaaba -> aabbbbbaabbababbbbbaabbaba
baabbbbbaaa -> aabbbbbaabbababbbbbaabbaa

# < a,b | baabbbbbaabbbaa=a >
baabbbbbaabbbaa -> a
baabbbbbaabba -> abbbbbaabbbaa
baabbbbbaaba -> abbbbbaabbbaaabbbbbaabbbaa
baabbbbbaaa -> abbbbbaabbbaaabbbbbaabbbaaabbbbbaabbbaa

# < a,b | baabbbbbabbbbba=a >
baabbbbbabbbbba -> a
baabbbbbabbbba -> aabbbbbabbbbba
baabbbbbabbba -> aabbbbbabbbba
baabbbbbabba -> aabbbbbabbba
baabbbbbaba -> aabbbbbabba
baabbbbbaa -> aabbbbbaba
baabbbba -> aabbbbbababbbbbabbbbba
baabbba -> aabbbbbababbbbbabbbba
baabba -> aabbbbbababbbbbabbba
baaba -> aabbbbbababbbbbabba
baaa -> aabbbbbababbbbbaba

# < a,b | baabbbbbbaababa=a >
baabbbbbbaababa -> a
baabbbbbbaabaa -> aabbbbbbaababa
baabbbbbbaaa -> aabbbbbbaabababbbbbbaababa

# < a,b | baabbbbbbaabbaa=a >
baabbbbbbaabbaa -> a
baabbbbbbaaba -> abbbbbbaabbaa
baabbbbbbaaa -> abbbbbbaabbaaabbbbbbaabbaa

# < a,b | babaaaaaaababba=a >
babaaaaaaababba -> a
babaaaaaaababa -> abaaaaaaababba
babaaaaaaabaa -> abaaaaaaababa
babaaaaaaaa -> abaaaaaaababbaaaaaaababba

# < a,b | babaaaaaabababa=a >
babaaaaaabababa -> a
babaaaaaababaa -> abaaaaaabababa
babaaaaaabaa -> aaaaaabababa
babaaaaaaa -> abaaaaaabababaaaaabababa

# < a,b | babaaaaaababbba=a >
babaaaaaababbba -> a
babaaaaaababba -> abaaaaaababbba
babaaaaaababa -> abaaaaaababba
babaaaaaabaa -> abaaaaaababa
babaaaaaaa -> abaaaaaababbaaaaaababbba

# < a,b | babaaaaaabbabaa=a >
babaaaaaabbabaa -> a
babaaaaaaba -> aaaaabbabaa
babaaaaaaa -> aaaaabbabaabaaaaaabbabaa

# < a,b | babaaaaaabbabba=a >
babaaaaaabbabba -> a
babaaaaaabbaba -> abaaaaaabbabba
babaaaaaabbaa -> abaaaaaabbaba
babaaaaaaba -> abaaaaaabbabbaaaaaabbabba
babaaaaaaa -> abaaaaaabbabbaaaaaabbaba

# < a,b | babaaaaaabbbaba=a >
babaaaaaabbbaba -> a
babaaaaaabbbaa -> abaaaaaabbbaba
babaaaaaabba -> aaaaaabbbaba
babaaaaaaba -> aaaaaabbbaa
babaaaaaaa -> aaaaaabbbaabaaaaaabbbaba

# < a,b | babaaaaababaaba=a >
babaaaaababaaba -> a
babaaaaababaaa -> abaaaaababaaba
babaaaaaa -> abaaaaababaabaaababaaba

# < a,b | babaaaaabababba=a >
babaaaaabababba -> a
babaaaaabababa -> abaaaaabababba
babaaaaababaa -> abaaaaabababa
babaaaaabaa -> abaaaaabababbaaaaabababba
babaaaaaa -> abaaaaabababaaaabababba

# < a,b | babaaaaababbbba=a >
babaaaaababbbba -> a
babaaaaababbba -> abaaaaababbbba
babaaaaababba -> abaaaaababbba
babaaaaababa -> abaaaaababba
babaaaaabaa -> abaaaaababa
babaaaaaa -> abaaaaababbaaaaababbbba

# < a,b | babaaaaabbabaaa=a >
babaaaaabbabaaa -> a
babaaaaaba -> aaabbabaaa
babaaaaaa -> aaabbabaaabaaaaabbabaaa

# < a,b | babaaaaabbababa=a >
babaaaaabbababa -> a
babaaaaabbabaa -> abaaaaabbababa
babaaaaabbaa -> aaaaabbababa
babaaaaaba -> abaaaaabbababaaaabbababa
babaaaaaa -> abaaaaabbababaaaabbabaa

# < a,b | babaaaaabbabbba=a >
babaaaaabbabbba -> a
babaaaaabbabba -> abaaaaabbabbba
babaaaaabbaba -> abaaaaabbabba
babaaaaabbaa -> abaaaaabbaba
babaaaaaba -> abaaaaabbabbaaaaabbabbba
babaaaaaa -> abaaaaabbabbaaaaabbabba

# < a,b | babaaaaabbbabaa=a >
babaaaaabbbabaa -> a
babaaaaabba -> aaaabbbabaa
babaaaaaba -> aaaabbbabaabaaaaabbbabaa
babaaaaaa -> aaaabbbabaabaaaaabbbabaabaaaaabbbabaa

# < a,b | babaaaaabbbabba=a >
babaaaaabbbabba -> a
babaaaaabbbaba -> abaaaaabbbabba
babaaaaabbbaa -> abaaaaabbbaba
babaaaaabba -> abaaaaabbbabbaaaaabbbabba
babaaaaaba -> abaaaaabbbabbaaaaabbbaba
babaaaaaa -> abaaaaabbbabbaaaaabbbaa

# < a,b | babaaaaabbbbaba=a >
babaaaaabbbbaba -> a
babaaaaabbbbaa -> abaaaaabbbbaba
babaaaaabbba -> aaaaabbbbaba
babaaaaabba -> aaaaabbbbaa
babaaaaaba -> aaaaabbbbaabaaaaabbbbaba
babaaaaaa -> aaaaabbbbaabaaaaabbbbaa

# < a,b | babaaaabaababba=a >
babaaaabaababba -> a
babaaaabaababa -> abaaaabaababba
babaaaabaabaa -> abaaaabaababa
babaaaabaaa -> abaaaabaababbaaaabaababba

# < a,b | babaaaababaaaba=a >
babaaaababaaaba -> a
babaaaababaaaa -> abaaaababaaaba
babaaaaa -> abaaaababaaabababaaaba

# < a,b | babaaaababaabba=a >
babaaaababaabba -> a
babaaaababaaba -> abaaaababaabba
babaaaababaaa -> abaaaababaaba
babaaaaa -> abaaaababaabaababaabba

# < a,b | babaaaababababa=a >
babaaaababababa -> a
babaaaabababaa -> abaaaababababa
babaaaababaa -> aaaababababa
babaaaabaa -> abaaaababababaaababababa
babaaaaa -> aaaababababaaababababa

# < a,b | babaaaabababbba=a >
babaaaabababbba -> a
babaaaabababba -> abaaaabababbba
babaaaabababa -> abaaaabababba
babaaaababaa -> abaaaabababa
babaaaabaa -> abaaaabababbaaaabababbba
babaaaaa -> abaaaabababaaabababbba

# < a,b | babaaaababbabba=a >
babaaaababbabba -> a
babaaaababbaba -> abaaaababbabba
babaaaababbaa -> abaaaababbaba
babaaaababa -> abaaaababbabbaaaababbabba
babaaaabaa -> abaaaababbabbaaaababbaba
babaaaaa -> abaaaababbabbaaaababbabbaaaababbabba

# < a,b | babaaaababbbaba=a >
babaaaababbbaba -> a
babaaaababbbaa -> abaaaababbbaba
babaaaababba -> aaaababbbaba
babaaaababa -> aaaababbbaa
babaaaabaa -> aaaababbbaabaaaababbbaba
babaaaaa -> aaaababbbaaaaababbbaba

# < a,b | babaaaababbbbba=a >
babaaaababbbbba -> a
babaaaababbbba -> abaaaababbbbba
babaaaababbba -> abaaaababbbba
babaaaababba -> abaaaababbba
babaaaababa -> abaaaababba
babaaaabaa -> abaaaababa
babaaaaa -> abaaaababbaaaababbbbba

# < a,b | babaaaabbabaaba=a >
babaaaabbabaaba -> a
babaaaabbabaaa -> abaaaabbabaaba
babaaaaba -> abaaaabbabaabaabbabaaba
babaaaaa -> abaaaabbabaabaabbabaaa

# < a,b | babaaaabbababba=a >
babaaaabbababba -> a
babaaaabbababa -> abaaaabbababba
babaaaabbabaa -> abaaaabbababa
babaaaabbaa -> abaaaabbababbaaaabbababba
babaaaaba -> abaaaabbababaaabbababba
babaaaaa -> abaaaabbababaaabbababa

# < a,b | babaaaabbabbbba=a >
babaaaabbabbbba -> a
babaaaabbabbba -> abaaaabbabbbba
babaaaabbabba -> abaaaabbabbba
babaaaabbaba -> abaaaabbabba
babaaaabbaa -> abaaaabbaba
babaaaaba -> abaaaabbabbaaaabbabbbba
babaaaaa -> abaaaabbabbaaaabbabbba

# < a,b | babaaaabbbabaaa=a >
babaaaabbbabaaa -> a
babaaaabba -> aabbbabaaa
babaaaaba -> aabbbabaaabaaaabbbabaaa
babaaaaa -> aabbbabaaabaaaabbbabaaabaaaabbbabaaa

# < a,b | babaaaabbbababa=a >
babaaaabbbababa -> a
babaaaabbbabaa -> abaaaabbbababa
babaaaabbbaa -> aaaabbbababa
babaaaabba -> abaaaabbbababaaabbbababa
babaaaaba -> abaaaabbbababaaabbbabaa
babaaaaa -> abaaaabbbababaaabbbabaabaaaabbbababa

# < a,b | babaaaabbbabbba=a >
babaaaabbbabbba -> a
babaaaabbbabba -> abaaaabbbabbba
babaaaabbbaba -> abaaaabbbabba
babaaaabbbaa -> abaaaabbbaba
babaaaabba -> abaaaabbbabbaaaabbbabbba
babaaaaba -> abaaaabbbabbaaaabbbabba
babaaaaa -> abaaaabbbabbaaaabbbaba

# < a,b | babaaaabbbbabaa=a >
babaaaabbbbabaa -> a
babaaaabbba -> aaabbbbabaa
babaaaabba -> aaabbbbabaabaaaabbbbabaa
babaaaaba -> aaabbbbabaabaaaabbbbabaabaaaabbbbabaa
babaaaaa -> aaabbbbabaabaaaabbbbabaabaaaabbbbabaabaaaabbbbabaa

# < a,b | babaaaabbbbabba=a >
babaaaabbbbabba -> a
babaaaabbbbaba -> abaaaabbbbabba
babaaaabbbbaa -> abaaaabbbbaba
babaaaabbba -> abaaaabbbbabbaaaabbbbabba
babaaaabba -> abaaaabbbbabbaaaabbbbaba
babaaaaba -> abaaaabbbbabbaaaabbbbaa
babaaaaa -> abaaaabbbbabbaaaabbbbaabaaaabbbbabba

# < a,b | babaaaabbbbbaba=a >
babaaaabbbbbaba -> a
babaaaabbbbbaa -> abaaaabbbbbaba
babaaaabbbba -> aaaabbbbbaba
babaaaabbba -> aaaabbbbbaa
babaaaabba -> aaaabbbbbaabaaaabbbbbaba
babaaaaba -> aaaabbbbbaabaaaabbbbbaa
babaaaaa -> aaaabbbbbaabaaaabbbbbaabaaaabbbbbaba

# < a,b | babaaabaaababba=a >
babaaabaaababba -> a
babaaabaaababa -> abaaabaaababba
babaaabaaabaa -> abaaabaaababa
babaaabaaaa -> abaaabaaababbaaabaaababba

# < a,b | babaaabaabababa=a >
babaaabaabababa -> a
babaaabaababaa -> abaaabaabababa
babaaabaabaa -> aaabaabababa
babaaabaaa -> abaaabaabababaabaabababa

# < a,b | babaaabaababbba=a >
babaaabaababbba -> a
babaaabaababba -> abaaabaababbba
babaaabaababa -> abaaabaababba
babaaabaabaa -> abaaabaababa
babaaabaaa -> abaaabaababbaaabaababbba

# < a,b | babaaabaabbabaa=a >
babaaabaabbabaa -> a
babaaabaaba -> aabaabbabaa
babaaabaaa -> aabaabbabaabaaabaabbabaa

# < a,b | babaaabaabbabba=a >
babaaabaabbabba -> a
babaaabaabbaba -> abaaabaabbabba
babaaabaabbaa -> abaaabaabbaba
babaaabaaba -> abaaabaabbabbaaabaabbabba
babaaabaaa -> abaaabaabbabbaaabaabbaba

# < a,b | babaaabaabbbaba=a >
babaaabaabbbaba -> a
babaaabaabbbaa -> abaaabaabbbaba
babaaabaabba -> aaabaabbbaba
babaaabaaba -> aaabaabbbaa
babaaabaaa -> aaabaabbbaabaaabaabbbaba

# < a,b | babaaababaaabba=a >
babaaababaaabba -> a
babaaababaaaba -> abaaababaaabba
babaaaa -> abaaababaaabbabaaabba

# < a,b | babaaababaababa=a >
babaaababaababa -> a
babaaababaabaa -> abaaababaababa
babaaababaaa -> aaababaababa
babaaaa -> aaababaababababaababa

# < a,b | babaaababaabbba=a >
babaaababaabbba -> a
babaaababaabba -> abaaababaabbba
babaaababaaba -> abaaababaabba
babaaababaaa -> abaaababaaba
babaaaa -> abaaababaabababaabbba

# < a,b | babaaabababaaba=a >
babaaabababaaba -> a
babaaabababaaa -> abaaabababaaba
babaaabaa -> abaaabababaababababaaba

# < a,b | babaaababababba=a >
babaaababababba -> a
babaaababababa -> abaaababababba
babaaabababaa -> abaaababababa
babaaababaa -> abaaababababbaaababababba
babaaabaa -> abaaababababaababababba
babaaaa -> abaaababababbaaababababbaababababba

# < a,b | babaaabababbaba=a >
babaaabababbaba -> a
babaaabababbaa -> abaaabababbaba
babaaabababa -> aaabababbaba
babaaababaa -> aaabababbaa
babaaabaa -> aaabababa
babaaaa -> aaabababbaaabababbaba

# < a,b | babaaabababbbba=a >
babaaabababbbba -> a
babaaabababbba -> abaaabababbbba
babaaabababba -> abaaabababbba
babaaabababa -> abaaabababba
babaaababaa -> abaaabababa
babaaabaa -> abaaabababbaaabababbbba
babaaaa -> abaaabababaabababbbba

# < a,b | babaaababbababa=a >
babaaababbababa -> a
babaaababbabaa -> abaaababbababa
babaaababbaa -> aaababbababa
babaaababa -> abaaababbababaababbababa
babaaabaa -> abaaababbababaababbabaa
babaaaa -> abaaababbababaababbaa

# < a,b | babaaababbabbba=a >
babaaababbabbba -> a
babaaababbabba -> abaaababbabbba
babaaababbaba -> abaaababbabba
babaaababbaa -> abaaababbaba
babaaababa -> abaaababbabbaaababbabbba
babaaabaa -> abaaababbabbaaababbabba
babaaaa -> abaaababbabbaaababbabbbaaababbabbba

# < a,b | babaaababbbabba=a >
babaaababbbabba -> a
babaaababbbaba -> abaaababbbabba
babaaababbbaa -> abaaababbbaba
babaaababba -> abaaababbbabbaaababbbabba
babaaababa -> abaaababbbabbaaababbbaba
babaaabaa -> abaaababbbabbaaababbbaa
babaaaa -> abaaababbbabbaaababba

# < a,b | babaaababbbbaba=a >
babaaababbbbaba -> a
babaaababbbbaa -> abaaababbbbaba
babaaababbba -> aaababbbbaba
babaaababba -> aaababbbbaa
babaaababa -> aaababbbbaabaaababbbbaba
babaaabaa -> aaababbbbaabaaababbbbaa
babaaaa -> aaababbbbaabaaababbba

# < a,b | babaaababbbbbba=a >
babaaababbbbbba -> a
babaaababbbbba -> abaaababbbbbba
babaaababbbba -> abaaababbbbba
babaaababbba -> abaaababbbba
babaaababba -> abaaababbba
babaaababa -> abaaababba
babaaabaa -> abaaababa
babaaaa -> abaaababbaaababbbbbba

# < a,b | babaaabbaababba=a >
babaaabbaababba -> a
babaaabbaababa -> abaaabbaababba
babaaabbaabaa -> abaaabbaababa
babaaabbaaa -> abaaabbaababbaaabbaababba

# < a,b | babaaabbabaabba=a >
babaaabbabaabba -> a
babaaabbabaaba -> abaaabbabaabba
babaaabbabaaa -> abaaabbabaaba
babaaaba -> abaaabbabaababbabaabba
babaaaa -> abaaabbabaababbabaaba

# < a,b | babaaabbabababa=a >
babaaabbabababa -> a
babaaabbababaa -> abaaabbabababa
babaaabbabaa -> aaabbabababa
babaaabbaa -> abaaabbabababaabbabababa
babaaaba -> aaabbabababaabbabababa
babaaaa -> aaabbabababaabbababaa

# < a,b | babaaabbababbba=a >
babaaabbababbba -> a
babaaabbababba -> abaaabbababbba
babaaabbababa -> abaaabbababba
babaaabbabaa -> abaaabbababa
babaaabbaa -> abaaabbababbaaabbababbba
babaaaba -> abaaabbababaabbababbba
babaaaa -> abaaabbababaabbababba

# < a,b | babaaabbabbabba=a >
babaaabbabbabba -> a
babaaabbabbaba -> abaaabbabbabba
babaaabbabbaa -> abaaabbabbaba
babaaabbaba -> abaaabbabbabbaaabbabbabba
babaaabbaa -> abaaabbabbabbaaabbabbaba
babaaaba -> abaaabbabbabbaaabbabbabbaaabbabbabba
babaaaa -> abaaabbabbabbaaabbabbabbaaabbabbaba

# < a,b | babaaabbabbbaba=a >
babaaabbabbbaba -> a
babaaabbabbbaa -> abaaabbabbbaba
babaaabbabba -> aaabbabbbaba
babaaabbaba -> aaabbabbbaa
babaaabbaa -> aaabbabbbaabaaabbabbbaba
babaaaba -> aaabbabbbaaaabbabbbaba
babaaaa -> aaabbabbbaaaabbabbbaa

# < a,b | babaaabbabbbbba=a >
babaaabbabbbbba -> a
babaaabbabbbba -> abaaabbabbbbba
babaaabbabbba -> abaaabbabbbba
babaaabbabba -> abaaabbabbba
babaaabbaba -> abaaabbabba
babaaabbaa -> abaaabbaba
babaaaba -> abaaabbabbaaabbabbbbba
babaaaa -> abaaabbabbaaabbabbbba

# < a,b | babaaabbbababba=a >
babaaabbbababba -> a
babaaabbbababa -> abaaabbbababba
babaaabbbabaa -> abaaabbbababa
babaaabbbaa -> abaaabbbababbaaabbbababba
babaaabba -> abaaabbbababaabbbababba
babaaaba -> abaaabbbababaabbbababa
babaaaa -> abaaabbbababaabbbabaa

# < a,b | babaaabbbabbaba=a >
babaaabbbabbaba -> a
babaaabbbabbaa -> abaaabbbabbaba
babaaabbbaba -> aaabbbabbaba
babaaabbbaa -> aaabbbabbaa
babaaabba -> aaabbbaba
babaaaba -> aaabbbaa
babaaaa -> aaabbbaabaaabbbabbaba

# < a,b | babaaabbbabbbba=a >
babaaabbbabbbba -> a
babaaabbbabbba -> abaaabbbabbbba
babaaabbbabba -> abaaabbbabbba
babaaabbbaba -> abaaabbbabba
babaaabbbaa -> abaaabbbaba
babaaabba -> abaaabbbabbaaabbbabbbba
babaaaba -> abaaabbbabbaaabbbabbba
babaaaa -> abaaabbbabbaaabbbabba

# < a,b | babaaabbbbababa=a >
babaaabbbbababa -> a
babaaabbbbabaa -> abaaabbbbababa
babaaabbbbaa -> aaabbbbababa
babaaabbba -> abaaabbbbababaabbbbababa
babaaabba -> abaaabbbbababaabbbbabaa
babaaaba -> abaaabbbbababaabbbbabaabaaabbbbababa
babaaaa -> abaaabbbbababaabbbbabaabaaabbbbabaa

# < a,b | babaaabbbbabbba=a >
babaaabbbbabbba -> a
babaaabbbbabba -> abaaabbbbabbba
babaaabbbbaba -> abaaabbbbabba
babaaabbbbaa -> abaaabbbbaba
babaaabbba -> abaaabbbbabbaaabbbbabbba
babaaabba -> abaaabbbbabbaaabbbbabba
babaaaba -> abaaabbbbabbaaabbbbaba
babaaaa -> abaaabbbbabbaaabbbbaa

# < a,b | babaaabbbbbabaa=a >
babaaabbbbbabaa -> a
babaaabbbba -> aabbbbbabaa
babaaabbba -> aabbbbbabaabaaabbbbbabaa
babaaabba -> aabbbbbabaabaaabbbbbabaabaaabbbbbabaa
babaaaba -> aabbbbbabaabaaabbbbbabaabaaabbbbbabaabaaabbbbbabaa
babaaaa -> aabbbbbabaabaaabbbbbabaabaaabbbbbabaabaaabbbbbabaabaaabbbbbabaa

# < a,b | babaaabbbbbabba=a >
babaaabbbbbabba -> a
babaaabbbbbaba -> abaaabbbbbabba
babaaabbbbbaa -> abaaabbbbbaba
babaaabbbba -> abaaabbbbbabbaaabbbbbabba
babaaabbba -> abaaabbbbbabbaaabbbbbaba
babaaabba -> abaaabbbbbabbaaabbbbbaa
babaaaba -> abaaabbbbbabbaaabbbbbaabaaabbbbbabba
babaaaa -> abaaabbbbbabbaaabbbbbaabaaabbbbbaba

# < a,b | babaaabbbbbbaba=a >
babaaabbbbbbaba -> a
babaaabbbbbbaa -> abaaabbbbbbaba
babaaabbbbba -> aaabbbbbbaba
babaaabbbba -> aaabbbbbbaa
babaaabbba -> aaabbbbbbaabaaabbbbbbaba
babaaabba -> aaabbbbbbaabaaabbbbbbaa
babaaaba -> aaabbbbbbaabaaabbbbbbaabaaabbbbbbaba
babaaaa -> aaabbbbbbaabaaabbbbbbaabaaabbbbbbaa

# < a,b | babaabaaaababba=a >
babaabaaaababba -> a
babaabaaaababa -> abaabaaaababba
babaabaaaabaa -> abaabaaaababa
babaabaaaaa -> abaabaaaababbaabaaaababba

# < a,b | babaabaaabababa=a >
babaabaaabababa -> a
babaabaaababaa -> abaabaaabababa
babaabaaabaa -> aabaaabababa
babaabaaaa -> abaabaaababababaaabababa

# < a,b | babaabaaababbba=a >
babaabaaababbba -> a
babaabaaababba -> abaabaaababbba
babaabaaababa -> abaabaaababba
babaabaaabaa -> abaabaaababa
babaabaaaa -> abaabaaababbaabaaababbba

# < a,b | babaabaaabbabaa=a >
babaabaaabbabaa -> a
babaabaaaba -> abaaabbabaa
babaabaaaa -> abaaabbabaabaabaaabbabaa

# < a,b | babaabaaabbabba=a >
babaabaaabbabba -> a
babaabaaabbaba -> abaabaaabbabba
babaabaaabbaa -> abaabaaabbaba
babaabaaaba -> abaabaaabbabbaabaaabbabba
babaabaaaa -> abaabaaabbabbaabaaabbaba

# < a,b | babaabaaabbbaba=a >
babaabaaabbbaba -> a
babaabaaabbbaa -> abaabaaabbbaba
babaabaaabba -> aabaaabbbaba
babaabaaaba -> aabaaabbbaa
babaabaaaa -> aabaaabbbaabaabaaabbbaba

# < a,b | babaabaabababba=a >
babaabaabababba -> a
babaabaabababa -> abaabaabababba
babaabaababaa -> abaabaabababa
babaabaabaa -> abaabaabababbaabaabababba
babaabaaa -> abaabaababababaabababba

# < a,b | babaabaababbbba=a >
babaabaababbbba -> a
babaabaababbba -> abaabaababbbba
babaabaababba -> abaabaababbba
babaabaababa -> abaabaababba
babaabaabaa -> abaabaababa
babaabaaa -> abaabaababbaabaababbbba

# < a,b | babaabaabbababa=a >
babaabaabbababa -> a
babaabaabbabaa -> abaabaabbababa
babaabaabbaa -> aabaabbababa
babaabaaba -> abaabaabbabababaabbababa
babaabaaa -> abaabaabbabababaabbabaa

# < a,b | babaabaabbabbba=a >
babaabaabbabbba -> a
babaabaabbabba -> abaabaabbabbba
babaabaabbaba -> abaabaabbabba
babaabaabbaa -> abaabaabbaba
babaabaaba -> abaabaabbabbaabaabbabbba
babaabaaa -> abaabaabbabbaabaabbabba

# < a,b | babaabaabbbabba=a >
babaabaabbbabba -> a
babaabaabbbaba -> abaabaabbbabba
babaabaabbbaa -> abaabaabbbaba
babaabaabba -> abaabaabbbabbaabaabbbabba
babaabaaba -> abaabaabbbabbaabaabbbaba
babaabaaa -> abaabaabbbabbaabaabbbaa

# < a,b | babaabaabbbbaba=a >
babaabaabbbbaba -> a
babaabaabbbbaa -> abaabaabbbbaba
babaabaabbba -> aabaabbbbaba
babaabaabba -> aabaabbbbaa
babaabaaba -> aabaabbbbaabaabaabbbbaba
babaabaaa -> aabaabbbbaabaabaabbbbaa

# < a,b | babaababaababba=a >
babaababaababba -> a
babaababaababa -> abaababaababba
babaababaabaa -> abaababaababa
babaaa -> abaababaababbaababba

# < a,b | babaababaabbaba=a >
babaababaabbaba -> a
babaababaabbaa -> abaababaabbaba
babaababaaba -> aababaabbaba
babaaa -> aababaabbababaabbaba

# < a,b | babaababaabbbba=a >
babaababaabbbba -> a
babaababaabbba -> abaababaabbbba
babaababaabba -> abaababaabbba
babaababaaba -> abaababaabba
babaaa -> abaababaabbabaabbbba

# < a,b | babaabababaabba=a >
babaabababaabba -> a
babaabababaaba -> abaabababaabba
babaabababaaa -> abaabababaaba
babaabaa -> abaabababaabbababaabba

# < a,b | babaabababababa=a >
babaabababababa -> a
babaababababaa -> abaabababababa
babaabababaa -> aabababababa
babaababaa -> abaababababababababababa
babaabaa -> aababababababababababa
babaaa -> abaabababababababababababababababa

# < a,b | babaababababbba=a >
babaababababbba -> a
babaababababba -> abaababababbba
babaababababa -> abaababababba
babaabababaa -> abaababababa
babaababaa -> abaababababbaababababbba
babaabaa -> abaababababababababbba
babaaa -> abaababababbaababababbbababababbba

# < a,b | babaabababbabba=a >
babaabababbabba -> a
babaabababbaba -> abaabababbabba
babaabababbaa -> abaabababbaba
babaabababa -> abaabababbabbaabababbabba
babaababaa -> abaabababbabbaabababbaba
babaabaa -> abaabababbabbaabababbabbaabababbabba
babaaa -> abaabababbabbaabababbababababbabba

# < a,b | babaabababbbaba=a >
babaabababbbaba -> a
babaabababbbaa -> abaabababbbaba
babaabababba -> aabababbbaba
babaabababa -> aabababbbaa
babaababaa -> aabababbbaabaabababbbaba
babaabaa -> aabababbbaaabababbbaba
babaaa -> aabababbbaabaabababbbababababbbaba

# < a,b | babaabababbbbba=a >
babaabababbbbba -> a
babaabababbbba -> abaabababbbbba
babaabababbba -> abaabababbbba
babaabababba -> abaabababbba
babaabababa -> abaabababba
babaababaa -> abaabababa
babaabaa -> abaabababbaabababbbbba
babaaa -> abaababababababbbbba

# < a,b | babaababbababba=a >
babaababbababba -> a
babaababbababa -> abaababbababba
babaababbabaa -> abaababbababa
babaababbaa -> abaababbababbaababbababba
babaababa -> abaababbababababbababba
babaabaa -> abaababbababababbababa
babaaa -> abaababbababababbababbaababbababba

# < a,b | babaababbabbbba=a >
babaababbabbbba -> a
babaababbabbba -> abaababbabbbba
babaababbabba -> abaababbabbba
babaababbaba -> abaababbabba
babaababbaa -> abaababbaba
babaababa -> abaababbabbaababbabbbba
babaabaa -> abaababbabbaababbabbba
babaaa -> abaababbabbaababbabbbbaababbabbbba

# < a,b | babaababbbabbba=a >
babaababbbabbba -> a
babaababbbabba -> abaababbbabbba
babaababbbaba -> abaababbbabba
babaababbbaa -> abaababbbaba
babaababba -> abaababbbabbaababbbabbba
babaababa -> abaababbbabbaababbbabba
babaabaa -> abaababbbabbaababbbaba
babaaa -> abaababbbabbaababbbabbaababbbabbba

# < a,b | babaababbbbabba=a >
babaababbbbabba -> a
babaababbbbaba -> abaababbbbabba
babaababbbbaa -> abaababbbbaba
babaababbba -> abaababbbbabbaababbbbabba
babaababba -> abaababbbbabbaababbbbaba
babaababa -> abaababbbbabbaababbbbaa
babaabaa -> abaababbbbabbaababbbbaabaababbbbabba
babaaa -> abaababbbbabbaababbbbaaababbbbabba

# < a,b | babaababbbbbaba=a >
babaababbbbbaba -> a
babaababbbbbaa -> abaababbbbbaba
babaababbbba -> aababbbbbaba
babaababbba -> aababbbbbaa
babaababba -> aababbbbbaabaababbbbbaba
babaababa -> aababbbbbaabaababbbbbaa
babaabaa -> aababbbbbaabaababbbbbaabaababbbbbaba
babaaa -> aababbbbbaabaababbbbbaaababbbbbaba

# < a,b | babaababbbbbbba=a >
babaababbbbbbba -> a
babaababbbbbba -> abaababbbbbbba
babaababbbbba -> abaababbbbbba
babaababbbba -> abaababbbbba
babaababbba -> abaababbbba
babaababba -> abaababbba
babaababa -> abaababba
babaabaa -> abaababa
babaaa -> abaababbaababbbbbbba

# < a,b | babaabbaaababba=a >
babaabbaaababba -> a
babaabbaaababa -> abaabbaaababba
babaabbaaabaa -> abaabbaaababa
babaabbaaaa -> abaabbaaababbaabbaaababba

# < a,b | babaabbaabababa=a >
babaabbaabababa -> a
babaabbaababaa -> abaabbaabababa
babaabbaabaa -> aabbaabababa
babaabbaaa -> abaabbaababababbaabababa

# < a,b | babaabbaababbba=a >
babaabbaababbba -> a
babaabbaababba -> abaabbaababbba
babaabbaababa -> abaabbaababba
babaabbaabaa -> abaabbaababa
babaabbaaa -> abaabbaababbaabbaababbba

# < a,b | babaabbaabbabaa=a >
babaabbaabbabaa -> a
babaabbaaba -> abbaabbabaa
babaabbaaa -> abbaabbabaabaabbaabbabaa

# < a,b | babaabbaabbabba=a >
babaabbaabbabba -> a
babaabbaabbaba -> abaabbaabbabba
babaabbaabbaa -> abaabbaabbaba
babaabbaaba -> abaabbaabbabbaabbaabbabba
babaabbaaa -> abaabbaabbabbaabbaabbaba

# < a,b | babaabbaabbbaba=a >
babaabbaabbbaba -> a
babaabbaabbbaa -> abaabbaabbbaba
babaabbaabba -> aabbaabbbaba
babaabbaaba -> aabbaabbbaa
babaabbaaa -> aabbaabbbaabaabbaabbbaba

# < a,b | babaabbabaabbba=a >
babaabbabaabbba -> a
babaabbabaabba -> abaabbabaabbba
babaaba -> abaabbabaabbbabaabbba
babaaa -> abaabbabaabbbabaabba

# < a,b | babaabbabababba=a >
babaabbabababba -> a
babaabbabababa -> abaabbabababba
babaabbababaa -> abaabbabababa
babaabbabaa -> abaabbabababbaabbabababba
babaabbaa -> abaabbababababbabababba
babaaba -> abaabbabababbaabbabababbabbabababba
babaaa -> abaabbabababbaabbabababbabbabababa

# < a,b | babaabbababbaba=a >
babaabbababbaba -> a
babaabbababbaa -> abaabbababbaba
babaabbababa -> aabbababbaba
babaabbabaa -> aabbababbaa
babaabbaa -> aabbababa
babaaba -> aabbababbaabbababbaba
babaaa -> aabbababbaabbababbaa

# < a,b | babaabbababbbba=a >
babaabbababbbba -> a
babaabbababbba -> abaabbababbbba
babaabbababba -> abaabbababbba
babaabbababa -> abaabbababba
babaabbabaa -> abaabbababa
babaabbaa -> abaabbababbaabbababbbba
babaaba -> abaabbabababbababbbba
babaaa -> abaabbabababbababbba

# < a,b | babaabbabbababa=a >
babaabbabbababa -> a
babaabbabbabaa -> abaabbabbababa
babaabbabbaa -> aabbabbababa
babaabbaba -> abaabbabbabababbabbababa
babaabbaa -> abaabbabbabababbabbabaa
babaaba -> abaabbabbabababbabbaa
babaaa -> abaabbabbabababbabbaabaabbabbababa

# < a,b | babaabbabbabbba=a >
babaabbabbabbba -> a
babaabbabbabba -> abaabbabbabbba
babaabbabbaba -> abaabbabbabba
babaabbabbaa -> abaabbabbaba
babaabbaba -> abaabbabbabbaabbabbabbba
babaabbaa -> abaabbabbabbaabbabbabba
babaaba -> abaabbabbabbaabbabbabbbaabbabbabbba
babaaa -> abaabbabbabbaabbabbabbbaabbabbabba

# < a,b | babaabbabbbabba=a >
babaabbabbbabba -> a
babaabbabbbaba -> abaabbabbbabba
babaabbabbbaa -> abaabbabbbaba
babaabbabba -> abaabbabbbabbaabbabbbabba
babaabbaba -> abaabbabbbabbaabbabbbaba
babaabbaa -> abaabbabbbabbaabbabbbaa
babaaba -> abaabbabbbabbaabbabba
babaaa -> abaabbabbbabbaabbaba

# < a,b | babaabbabbbbaba=a >
babaabbabbbbaba -> a
babaabbabbbbaa -> abaabbabbbbaba
babaabbabbba -> aabbabbbbaba
babaabbabba -> aabbabbbbaa
babaabbaba -> aabbabbbbaabaabbabbbbaba
babaabbaa -> aabbabbbbaabaabbabbbbaa
babaaba -> aabbabbbbaabaabbabbba
babaaa -> aabbabbbbaabaabbabba

# < a,b | babaabbabbbbbba=a >
babaabbabbbbbba -> a
babaabbabbbbba -> abaabbabbbbbba
babaabbabbbba -> abaabbabbbbba
babaabbabbba -> abaabbabbbba
babaabbabba -> abaabbabbba
babaabbaba -> abaabbabba
babaabbaa -> abaabbaba
babaaba -> abaabbabbaabbabbbbbba
babaaa -> abaabbabbaabbabbbbba

# < a,b | babaabbbaababba=a >
babaabbbaababba -> a
babaabbbaababa -> abaabbbaababba
babaabbbaabaa -> abaabbbaababa
babaabbbaaa -> abaabbbaababbaabbbaababba

# < a,b | babaabbbababbba=a >
babaabbbababbba -> a
babaabbbababba -> abaabbbababbba
babaabbbababa -> abaabbbababba
babaabbbabaa -> abaabbbababa
babaabbbaa -> abaabbbababbaabbbababbba
babaabba -> abaabbbabababbbababbba
babaaba -> abaabbbabababbbababba
babaaa -> abaabbbabababbbababa

# < a,b | babaabbbabbabba=a >
babaabbbabbabba -> a
babaabbbabbaba -> abaabbbabbabba
babaabbbabbaa -> abaabbbabbaba
babaabbbaba -> abaabbbabbabbaabbbabbabba
babaabbbaa -> abaabbbabbabbaabbbabbaba
babaabba -> abaabbbabbabbaabbbabbabbaabbbabbabba
babaaba -> abaabbbabbabbaabbbabbabbaabbbabbaba
babaaa -> abaabbbabbabbaabbbabbabbaabbbabbaa

# < a,b | babaabbbabbbaba=a >
babaabbbabbbaba -> a
babaabbbabbbaa -> abaabbbabbbaba
babaabbbabba -> aabbbabbbaba
babaabbbaba -> aabbbabbbaa
babaabbbaa -> aabbbabbbaabaabbbabbbaba
babaabba -> aabbbabbbaaabbbabbbaba
babaaba -> aabbbabbbaaabbbabbbaa
babaaa -> aabbbabbbaaabbbabbbaabaabbbabbbaba

# < a,b | babaabbbabbbbba=a >
babaabbbabbbbba -> a
babaabbbabbbba -> abaabbbabbbbba
babaabbbabbba -> abaabbbabbbba
babaabbbabba -> abaabbbabbba
babaabbbaba -> abaabbbabba
babaabbbaa -> abaabbbaba
babaabba -> abaabbbabbaabbbabbbbba
babaaba -> abaabbbabbaabbbabbbba
babaaa -> abaabbbabbaabbbabbba

# < a,b | babaabbbbabbaba=a >
babaabbbbabbaba -> a
babaabbbbabbaa -> abaabbbbabbaba
babaabbbbaba -> aabbbbabbaba
babaabbbbaa -> aabbbbabbaa
babaabbba -> aabbbbaba
babaabba -> aabbbbaa
babaaba -> aabbbbaabaabbbbabbaba
babaaa -> aabbbbaabaabbbbabbaa

# < a,b | babaabbbbabbbba=a >
babaabbbbabbbba -> a
babaabbbbabbba -> abaabbbbabbbba
babaabbbbabba -> abaabbbbabbba
babaabbbbaba -> abaabbbbabba
babaabbbbaa -> abaabbbbaba
babaabbba -> abaabbbbabbaabbbbabbbba
babaabba -> abaabbbbabbaabbbbabbba
babaaba -> abaabbbbabbaabbbbabba
babaaa -> abaabbbbabbaabbbbaba

# < a,b | babaabbbbbabbba=a >
babaabbbbbabbba -> a
babaabbbbbabba -> abaabbbbbabbba
babaabbbbbaba -> abaabbbbbabba
babaabbbbbaa -> abaabbbbbaba
babaabbbba -> abaabbbbbabbaabbbbbabbba
babaabbba -> abaabbbbbabbaabbbbbabba
babaabba -> abaabbbbbabbaabbbbbaba
babaaba -> abaabbbbbabbaabbbbbaa
babaaa -> abaabbbbbabbaabbbbbaabaabbbbbabbba

# < a,b | babaabbbbbbabba=a >
babaabbbbbbabba -> a
babaabbbbbbaba -> abaabbbbbbabba
babaabbbbbbaa -> abaabbbbbbaba
babaabbbbba -> abaabbbbbbabbaabbbbbbabba
babaabbbba -> abaabbbbbbabbaabbbbbbaba
babaabbba -> abaabbbbbbabbaabbbbbbaa
babaabba -> abaabbbbbbabbaabbbbbbaabaabbbbbbabba
babaaba -> abaabbbbbbabbaabbbbbbaabaabbbbbbaba
babaaa -> abaabbbbbbabbaabbbbbbaabaabbbbbbaa

# < a,b | babaabbbbbbbaba=a >
babaabbbbbbbaba -> a
babaabbbbbbbaa -> abaabbbbbbbaba
babaabbbbbba -> aabbbbbbbaba
babaabbbbba -> aabbbbbbbaa
babaabbbba -> aabbbbbbbaabaabbbbbbbaba
babaabbba -> aabbbbbbbaabaabbbbbbbaa
babaabba -> aabbbbbbbaabaabbbbbbbaabaabbbbbbbaba
babaaba -> aabbbbbbbaabaabbbbbbbaabaabbbbbbbaa
babaaa -> aabbbbbbbaabaabbbbbbbaabaabbbbbbbaabaabbbbbbbaba

# < a,b | bababaaaaababba=a >
bababaaaaababba -> a
bababaaaaababa -> ababaaaaababba
bababaaaaabaa -> ababaaaaababa
bababaaaaaa -> ababaaaaababbabaaaaababba

# < a,b | bababaaaababbba=a >
bababaaaababbba -> a
bababaaaababba -> ababaaaababbba
bababaaaababa -> ababaaaababba
bababaaaabaa -> ababaaaababa
bababaaaaa -> ababaaaababbabaaaababbba

# < a,b | bababaaaabbabba=a >
bababaaaabbabba -> a
bababaaaabbaba -> ababaaaabbabba
bababaaaabbaa -> ababaaaabbaba
bababaaaaba -> ababaaaabbabbabaaaabbabba
bababaaaaa -> ababaaaabbabbabaaaabbaba

# < a,b | bababaaaabbbaba=a >
bababaaaabbbaba -> a
bababaaaabbbaa -> ababaaaabbbaba
bababaaaabba -> abaaaabbbaba
bababaaaaba -> abaaaabbbaa
bababaaaaa -> abaaaabbbaababaaaabbbaba

# < a,b | bababaaabababba=a >
bababaaabababba -> a
bababaaabababa -> ababaaabababba
bababaaababaa -> ababaaabababa
bababaaabaa -> ababaaabababbabaaabababba
bababaaaa -> ababaaabababbaaabababba

# < a,b | bababaaababbbba=a >
bababaaababbbba -> a
bababaaababbba -> ababaaababbbba
bababaaababba -> ababaaababbba
bababaaababa -> ababaaababba
bababaaabaa -> ababaaababa
bababaaaa -> ababaaababbabaaababbbba

# < a,b | bababaaabbabbba=a >
bababaaabbabbba -> a
bababaaabbabba -> ababaaabbabbba
bababaaabbaba -> ababaaabbabba
bababaaabbaa -> ababaaabbaba
bababaaaba -> ababaaabbabbabaaabbabbba
bababaaaa -> ababaaabbabbabaaabbabba

# < a,b | bababaaabbbabba=a >
bababaaabbbabba -> a
bababaaabbbaba -> ababaaabbbabba
bababaaabbbaa -> ababaaabbbaba
bababaaabba -> ababaaabbbabbabaaabbbabba
bababaaaba -> ababaaabbbabbabaaabbbaba
bababaaaa -> ababaaabbbabbabaaabbbaa

# < a,b | bababaaabbbbaba=a >
bababaaabbbbaba -> a
bababaaabbbbaa -> ababaaabbbbaba
bababaaabbba -> abaaabbbbaba
bababaaabba -> abaaabbbbaa
bababaaaba -> abaaabbbbaababaaabbbbaba
bababaaaa -> abaaabbbbaababaaabbbbaa

# < a,b | bababaabaababba=a >
bababaabaababba -> a
bababaabaababa -> ababaabaababba
bababaabaabaa -> ababaabaababa
bababaabaaa -> ababaabaababbabaabaababba

# < a,b | bababaababababa=a >
bababaababababa -> a
bababaabababaa -> ababaababababa
bababaababaa -> abaababababa
bababaabaa -> aababababa
bababaaa -> ababaababababababababa

# < a,b | bababaabababbba=a >
bababaabababbba -> a
bababaabababba -> ababaabababbba
bababaabababa -> ababaabababba
bababaababaa -> ababaabababa
bababaabaa -> ababaabababbabaabababbba
bababaaa -> ababaabababbaabababbba

# < a,b | bababaababbabba=a >
bababaababbabba -> a
bababaababbaba -> ababaababbabba
bababaababbaa -> ababaababbaba
bababaababa -> ababaababbabbabaababbabba
bababaabaa -> ababaababbabbabaababbaba
bababaaa -> ababaababbabbabaababbabbabaababbabba

# < a,b | bababaababbbaba=a >
bababaababbbaba -> a
bababaababbbaa -> ababaababbbaba
bababaababba -> abaababbbaba
bababaababa -> abaababbbaa
bababaabaa -> abaababbbaababaababbbaba
bababaaa -> abaababbbaabaababbbaba

# < a,b | bababaababbbbba=a >
bababaababbbbba -> a
bababaababbbba -> ababaababbbbba
bababaababbba -> ababaababbbba
bababaababba -> ababaababbba
bababaababa -> ababaababba
bababaabaa -> ababaababa
bababaaa -> ababaababbabaababbbbba

# < a,b | bababaabbababba=a >
bababaabbababba -> a
bababaabbababa -> ababaabbababba
bababaabbabaa -> ababaabbababa
bababaabbaa -> ababaabbababbabaabbababba
bababaaba -> ababaabbababbaabbababba
bababaaa -> ababaabbababbaabbababa

# < a,b | bababaabbabbbba=a >
bababaabbabbbba -> a
bababaabbabbba -> ababaabbabbbba
bababaabbabba -> ababaabbabbba
bababaabbaba -> ababaabbabba
bababaabbaa -> ababaabbaba
bababaaba -> ababaabbabbabaabbabbbba
bababaaa -> ababaabbabbabaabbabbba

# < a,b | bababaabbbababa=a >
bababaabbbababa -> a
bababaabbbabaa -> ababaabbbababa
bababaabbbaa -> abaabbbababa
bababaabba -> aabbbababa
bababaaba -> aabbbabaa
bababaaa -> aabbbabaababaabbbababa

# < a,b | bababaabbbabbba=a >
bababaabbbabbba -> a
bababaabbbabba -> ababaabbbabbba
bababaabbbaba -> ababaabbbabba
bababaabbbaa -> ababaabbbaba
bababaabba -> ababaabbbabbabaabbbabbba
bababaaba -> ababaabbbabbabaabbbabba
bababaaa -> ababaabbbabbabaabbbaba

# < a,b | bababaabbbbabba=a >
bababaabbbbabba -> a
bababaabbbbaba -> ababaabbbbabba
bababaabbbbaa -> ababaabbbbaba
bababaabbba -> ababaabbbbabbabaabbbbabba
bababaabba -> ababaabbbbabbabaabbbbaba
bababaaba -> ababaabbbbabbabaabbbbaa
bababaaa -> ababaabbbbabbabaabbbbaababaabbbbabba

# < a,b | bababaabbbbbaba=a >
bababaabbbbbaba -> a
bababaabbbbbaa -> ababaabbbbbaba
bababaabbbba -> abaabbbbbaba
bababaabbba -> abaabbbbbaa
bababaabba -> abaabbbbbaababaabbbbbaba
bababaaba -> abaabbbbbaababaabbbbbaa
bababaaa -> abaabbbbbaababaabbbbbaababaabbbbbaba

# < a,b | babababaaababba=a >
babababaaababba -> a
babababaaababa -> abababaaababba
babababaaabaa -> abababaaababa
babababaaaa -> abababaaababbababaaababba

# < a,b | babababaababbba=a >
babababaababbba -> a
babababaababba -> abababaababbba
babababaababa -> abababaababba
babababaabaa -> abababaababa
babababaaa -> abababaababbababaababbba

# < a,b | babababaabbabba=a >
babababaabbabba -> a
babababaabbaba -> abababaabbabba
babababaabbaa -> abababaabbaba
babababaaba -> abababaabbabbababaabbabba
babababaaa -> abababaabbabbababaabbaba

# < a,b | babababaabbbaba=a >
babababaabbbaba -> a
babababaabbbaa -> abababaabbbaba
babababaabba -> ababaabbbaba
babababaaba -> ababaabbbaa
babababaaa -> ababaabbbaabababaabbbaba

# < a,b | bababababababba=a >
bababababababba -> a
bababababababa -> ababababababba
baa -> ababababababbabba

# < a,b | babababababbaba=a >
babababababbaba -> a
babababababa -> ababababbaba
baa -> ababababbababbaba

# < a,b | babababababbbba=a >
babababababbbba -> a
babababababbba -> abababababbbba
babababababba -> abababababbba
babababababa -> abababababba
baa -> abababababbabbbba

# < a,b | bababababbababa=a >
bababababbababa -> a
bababababa -> ababbababa
baa -> ababbabababbababa

# < a,b | bababababbabbba=a >
bababababbabbba -> a
bababababbabba -> ababababbabbba
bababababbaba -> ababababbabba
bababababa -> ababababbabbabababbabbba
baa -> ababababbabbabababbabbbabbabbba

# < a,b | bababababbbabba=a >
bababababbbabba -> a
bababababbbaba -> ababababbbabba
bababababba -> ababababbbabbabababbbabba
bababababa -> ababababbbabbabababbbaba
baa -> ababababbbabbabababbbababbbabba

# < a,b | bababababbbbbba=a >
bababababbbbbba -> a
bababababbbbba -> ababababbbbbba
bababababbbba -> ababababbbbba
bababababbba -> ababababbbba
bababababba -> ababababbba
bababababa -> ababababba
baa -> ababababbabbbbbba

# < a,b | babababbaababba=a >
babababbaababba -> a
babababbaababa -> abababbaababba
babababbaabaa -> abababbaababa
babababbaaa -> abababbaababbababbaababba

# < a,b | babababbababbba=a >
babababbababbba -> a
babababbababba -> abababbababbba
babababbababa -> abababbababba
babababa -> abababbababbabbababbba
baa -> abababbababbabbababbbabbababbba

# < a,b | babababbabbabba=a >
babababbabbabba -> a
babababbabbaba -> abababbabbabba
babababbaba -> abababbabbabbababbabbabba
babababa -> abababbabbabbababbabbabbababbabbabba
baa -> abababbabbabbababbabbabbababbabbabbabbabbabba

# < a,b | babababbabbbbba=a >
babababbabbbbba -> a
babababbabbbba -> abababbabbbbba
babababbabbba -> abababbabbbba
babababbabba -> abababbabbba
babababbaba -> abababbabba
babababa -> abababbabbababbabbbbba
baa -> abababbabbababbabbbbbabbabbbbba

# < a,b | babababbbababba=a >
babababbbababba -> a
babababbbababa -> abababbbababba
babababba -> abababbbababbabbbababba
babababa -> abababbbababbabbbababa
baa -> abababbbababbabba

# < a,b | babababbbabbbba=a >
babababbbabbbba -> a
babababbbabbba -> abababbbabbbba
babababbbabba -> abababbbabbba
babababbbaba -> abababbbabba
babababba -> abababbbabbababbbabbbba
babababa -> abababbbabbababbbabbba
baa -> abababbbabbababbbabbbabbbabbbba

# < a,b | babababbbbabbba=a >
babababbbbabbba -> a
babababbbbabba -> abababbbbabbba
babababbbbaba -> abababbbbabba
babababbba -> abababbbbabbababbbbabbba
babababba -> abababbbbabbababbbbabba
babababa -> abababbbbabbababbbbaba
baa -> abababbbbabbababbbbababbbbabbba

# < a,b | babababbbbbbbba=a >
babababbbbbbbba -> a
babababbbbbbba -> abababbbbbbbba
babababbbbbba -> abababbbbbbba
babababbbbba -> abababbbbbba
babababbbba -> abababbbbba
babababbba -> abababbbba
babababba -> abababbba
babababa -> abababba
baa -> abababbabbbbbbbba

# < a,b | bababbaaaababba=a >
bababbaaaababba -> a
bababbaaaababa -> ababbaaaababba
bababbaaaabaa -> ababbaaaababa
bababbaaaaa -> ababbaaaababbabbaaaababba

# < a,b | bababbaaababbba=a >
bababbaaababbba -> a
bababbaaababba -> ababbaaababbba
bababbaaababa -> ababbaaababba
bababbaaabaa -> ababbaaababa
bababbaaaa -> ababbaaababbabbaaababbba

# < a,b | bababbaaabbabba=a >
bababbaaabbabba -> a
bababbaaabbaba -> ababbaaabbabba
bababbaaabbaa -> ababbaaabbaba
bababbaaaba -> ababbaaabbabbabbaaabbabba
bababbaaaa -> ababbaaabbabbabbaaabbaba

# < a,b | bababbaaabbbaba=a >
bababbaaabbbaba -> a
bababbaaabbbaa -> ababbaaabbbaba
bababbaaabba -> abbaaabbbaba
bababbaaaba -> abbaaabbbaa
bababbaaaa -> abbaaabbbaababbaaabbbaba

# < a,b | bababbaabababba=a >
bababbaabababba -> a
bababbaabababa -> ababbaabababba
bababbaaa -> aabababba
bababbaababaa -> ababbaabababa
bababbaabaa -> ababbaabababbabbaabababba

# < a,b | bababbaababbbba=a >
bababbaababbbba -> a
bababbaababbba -> ababbaababbbba
bababbaababba -> ababbaababbba
bababbaababa -> ababbaababba
bababbaabaa -> ababbaababa
bababbaaa -> ababbaababbabbaababbbba

# < a,b | bababbaabbabbba=a >
bababbaabbabbba -> a
bababbaabbabba -> ababbaabbabbba
bababbaabbaba -> ababbaabbabba
bababbaabbaa -> ababbaabbaba
bababbaaba -> ababbaabbabbabbaabbabbba
bababbaaa -> ababbaabbabbabbaabbabba

# < a,b | bababbaabbbabba=a >
bababbaabbbabba -> a
bababbaabbbaba -> ababbaabbbabba
bababbaabbbaa -> ababbaabbbaba
bababbaabba -> ababbaabbbabbabbaabbbabba
bababbaaba -> ababbaabbbabbabbaabbbaba
bababbaaa -> ababbaabbbabbabbaabbbaa

# < a,b | bababbaabbbbaba=a >
bababbaabbbbaba -> a
bababbaabbbbaa -> ababbaabbbbaba
bababbaabbba -> abbaabbbbaba
bababbaabba -> abbaabbbbaa
bababbaaba -> abbaabbbbaababbaabbbbaba
bababbaaa -> abbaabbbbaababbaabbbbaa

# < a,b | bababbabaababba=a >
bababbabaababba -> a
bababbabaababa -> ababbabaababba
bababbabaabaa -> ababbabaababa
bababbabaaa -> ababbabaababbabbabaababba

# < a,b | bababbabababbba=a >
bababbabababbba -> a
bababbabababba -> ababbabababbba
bababbabababa -> ababbabababba
bababbaa -> ababbabababbbabababbba
bababbababaa -> ababbabababa
bababbabaa -> ababbabababbabbabababbba

# < a,b | bababbababbabba=a >
bababbababbabba -> a
bababbababbaba -> ababbababbabba
bababa -> ababbababbabbabbabba
baa -> ababbababbabbabbabbabbababbabba

# < a,b | bababbababbbbba=a >
bababbababbbbba -> a
bababbababbbba -> ababbababbbbba
bababbababbba -> ababbababbbba
bababbababba -> ababbababbba
bababa -> ababbababbbababbbbba
baa -> ababbababbbababbbbbabbababbbbba

# < a,b | bababbabbababba=a >
bababbabbababba -> a
bababbaba -> abbababba
bababa -> abbababbabbabbababba
baa -> abbababbabbabbababbabbabbababba

# < a,b | bababbabbabbbba=a >
bababbabbabbbba -> a
bababbabbabbba -> ababbabbabbbba
bababbabbabba -> ababbabbabbba
bababbabbaba -> ababbabbabba
bababbaba -> ababbabbabbabbabbabbbba
bababa -> ababbabbabbabbabbabbbbabbabbabbbba
baa -> ababbabbabbabbabbabbbbabbabbabbbbabbabbabbbba

# < a,b | bababbabbbabbba=a >
bababbabbbabbba -> a
bababbabbbabba -> ababbabbbabbba
bababbabbbaba -> ababbabbbabba
bababbabba -> ababbabbbabbabbabbbabbba
bababbaba -> ababbabbbabbabbabbbabba
bababa -> ababbabbbabbabbabbbabbabbabbbabbba
baa -> ababbabbbabbabbabbbabbabbabbbabbbabbabbbabbba

# < a,b | bababbabbbbbbba=a >
bababbabbbbbbba -> a
bababbabbbbbba -> ababbabbbbbbba
bababbabbbbba -> ababbabbbbbba
bababbabbbba -> ababbabbbbba
bababbabbba -> ababbabbbba
bababbabba -> ababbabbba
bababbaba -> ababbabba
bababa -> ababbabbabbabbbbbbba
baa -> ababbabbabbabbbbbbbabbabbbbbbba

# < a,b | bababbbaaababba=a >
bababbbaaababba -> a
bababbbaaababa -> ababbbaaababba
bababbbaaabaa -> ababbbaaababa
bababbbaaaa -> ababbbaaababbabbbaaababba

# < a,b | bababbbaababbba=a >
bababbbaababbba -> a
bababbbaababba -> ababbbaababbba
bababbbaababa -> ababbbaababba
bababbbaabaa -> ababbbaababa
bababbbaaa -> ababbbaababbabbbaababbba

# < a,b | bababbbaabbabba=a >
bababbbaabbabba -> a
bababbbaabbaba -> ababbbaabbabba
bababbbaabbaa -> ababbbaabbaba
bababbbaaba -> ababbbaabbabbabbbaabbabba
bababbbaaa -> ababbbaabbabbabbbaabbaba

# < a,b | bababbbaabbbaba=a >
bababbbaabbbaba -> a
bababbbaabbbaa -> ababbbaabbbaba
bababbbaabba -> abbbaabbbaba
bababbbaaba -> abbbaabbbaa
bababbbaaa -> abbbaabbbaababbbaabbbaba

# < a,b | bababbbabababba=a >
bababbbabababba -> a
bababbbabababa -> ababbbabababba
bababbbababaa -> ababbbabababa
bababbbabaa -> ababbbabababbabbbabababba

# < a,b | bababbbababbbba=a >
bababbbababbbba -> a
bababbbababbba -> ababbbababbbba
bababba -> ababbbababbbbababbbba
bababa -> ababbbababbbbababbba
baa -> ababbbababbbbababbbabbbababbbba

# < a,b | bababbbabbabbba=a >
bababbbabbabbba -> a
bababbbabbabba -> ababbbabbabbba
bababbbabbaba -> ababbbabbabba
bababbbaba -> ababbbabbabbabbbabbabbba
bababba -> ababbbabbabbabbbabbabbbabbbabbabbba
bababa -> ababbbabbabbabbbabbabbbabbbabbabba
baa -> ababbbabbabbabbbabbabbbabbbabbabbabbbabbabbba

# < a,b | bababbbabbbabba=a >
bababbbabbbabba -> a
bababbbabbbaba -> ababbbabbbabba
bababbbabba -> ababbbabbbabbabbbabbbabba
bababbbaba -> ababbbabbbabbabbbabbbaba
bababba -> ababbbabbbabbabbbabba
bababa -> ababbbabbbabbabbbaba
baa -> ababbbabbbabbabba

# < a,b | bababbbabbbbbba=a >
bababbbabbbbbba -> a
bababbbabbbbba -> ababbbabbbbbba
bababbbabbbba -> ababbbabbbbba
bababbbabbba -> ababbbabbbba
bababbbabba -> ababbbabbba
bababbbaba -> ababbbabba
bababba -> ababbbabbabbbabbbbbba
bababa -> ababbbabbabbbabbbbba
baa -> ababbbabbabbbabbbbbabbbabbbbbba

# < a,b | bababbbbaababba=a >
bababbbbaababba -> a
bababbbbaababa -> ababbbbaababba
bababbbbaabaa -> ababbbbaababa
bababbbbaaa -> ababbbbaababbabbbbaababba

# < a,b | bababbbbababbba=a >
bababbbbababbba -> a
bababbbbababba -> ababbbbababbba
bababbbbababa -> ababbbbababba
bababbbbabaa -> ababbbbababa
bababbbbaa -> ababbbbababbabbbbababbba

# < a,b | bababbbbabbbbba=a >
bababbbbabbbbba -> a
bababbbbabbbba -> ababbbbabbbbba
bababbbbabbba -> ababbbbabbbba
bababbbbabba -> ababbbbabbba
bababbbbaba -> ababbbbabba
bababbba -> ababbbbabbabbbbabbbbba
bababba -> ababbbbabbabbbbabbbba
bababa -> ababbbbabbabbbbabbba
baa -> ababbbbabbabbbbabbbabbbbabbbbba

# < a,b | bababbbbbababba=a >
bababbbbbababba -> a
bababbbbbababa -> ababbbbbababba
bababbbbbabaa -> ababbbbbababa
bababbbbbaa -> ababbbbbababbabbbbbababba

# < a,b | bababbbbbabbbba=a >
bababbbbbabbbba -> a
bababbbbbabbba -> ababbbbbabbbba
bababbbbbabba -> ababbbbbabbba
bababbbbbaba -> ababbbbbabba
bababbbba -> ababbbbbabbabbbbbabbbba
bababbba -> ababbbbbabbabbbbbabbba
bababba -> ababbbbbabbabbbbbabba
bababa -> ababbbbbabbabbbbbaba
baa -> ababbbbbabbabbbba

# < a,b | bababbbbbbbbbba=a >
bababbbbbbbbbba -> a
bababbbbbbbbba -> ababbbbbbbbbba
bababbbbbbbba -> ababbbbbbbbba
bababbbbbbba -> ababbbbbbbba
bababbbbbba -> ababbbbbbba
bababbbbba -> ababbbbbba
bababbbba -> ababbbbba
bababbba -> ababbbba
bababba -> ababbba
bababa -> ababba
baa -> ababbabbbbbbbbbba

# < a,b | babbaaaaababbba=a >
babbaaaaababbba -> a
babbaaaaababba -> abbaaaaababbba
babbaaaaababa -> abbaaaaababba
babbaaaaaa -> abbaaaaababbbaaaaababbba
babbaaaaabaa -> abbaaaaababa

# < a,b | babbaaaababbaba=a >
babbaaaababbaba -> a
babbaaaababbaa -> abbaaaababbaba
babbaaaaa -> abbaaaababbabaaababbaba

# < a,b | babbaaaababbbba=a >
babbaaaababbbba -> a
babbaaaababbba -> abbaaaababbbba
babbaaaababba -> abbaaaababbba
babbaaaababa -> abbaaaababba
babbaaaaa -> abbaaaababbbaaaababbbba
babbaaaabaa -> abbaaaababa

# < a,b | babbaaaabbabbaa=a >
babbaaaabbabbaa -> a
babbaaaaba -> aaabbabbaa
babbaaaaa -> aaabbabbaabbaaaabbabbaa

# < a,b | babbaaaabbabbba=a >
babbaaaabbabbba -> a
babbaaaabbabba -> abbaaaabbabbba
babbaaaabbaba -> abbaaaabbabba
babbaaaaba -> abbaaaabbabbbaaaabbabbba
babbaaaabbaa -> abbaaaabbaba
babbaaaaa -> abbaaaabbabbbaaaabbabba

# < a,b | babbaaabababbba=a >
babbaaabababbba -> a
babbaaabababba -> abbaaabababbba
babbaaabababa -> abbaaabababba
babbaaabaa -> abbaaabababbbaaabababbba
babbaaababaa -> abbaaabababa

# < a,b | babbaaababbaaba=a >
babbaaababbaaba -> a
babbaaababbaaa -> abbaaababbaaba
babbaaaa -> abbaaababbaabababbaaba

# < a,b | babbaaababbabba=a >
babbaaababbabba -> a
babbaaababbaba -> abbaaababbabba
babbaaababa -> aaababbabba
babbaaababbaa -> abbaaababbaba
babbaaabaa -> aaababbaba
babbaaaa -> abbaaababbabaababbabba

# < a,b | babbaaababbbbba=a >
babbaaababbbbba -> a
babbaaababbbba -> abbaaababbbbba
babbaaababbba -> abbaaababbbba
babbaaababba -> abbaaababbba
babbaaababa -> abbaaababba
babbaaaa -> abbaaababbbaaababbbbba
babbaaabaa -> abbaaababa

# < a,b | babbaaabbabbaaa=a >
babbaaabbabbaaa -> a
babbaaaba -> abbabbaaa
babbaaaa -> abbabbaaabbaaabbabbaaa

# < a,b | babbaaabbabbaba=a >
babbaaabbabbaba -> a
babbaaabbabbaa -> abbaaabbabbaba
babbaaaba -> abbaaabbabbabaabbabbaba
babbaaaa -> abbaaabbabbabaabbabbaa

# < a,b | babbaaabbabbbba=a >
babbaaabbabbbba -> a
babbaaabbabbba -> abbaaabbabbbba
babbaaabbabba -> abbaaabbabbba
babbaaabbaba -> abbaaabbabba
babbaaaba -> abbaaabbabbbaaabbabbbba
babbaaabbaa -> abbaaabbaba
babbaaaa -> abbaaabbabbbaaabbabbba

# < a,b | babbaaabbbabbaa=a >
babbaaabbbabbaa -> a
babbaaabba -> aabbbabbaa
babbaaaba -> aabbbabbaabbaaabbbabbaa
babbaaaa -> aabbbabbaabbaaabbbabbaabbaaabbbabbaa

# < a,b | babbaaabbbabbba=a >
babbaaabbbabbba -> a
babbaaabbbabba -> abbaaabbbabbba
babbaaabbbaba -> abbaaabbbabba
babbaaabba -> abbaaabbbabbbaaabbbabbba
babbaaabbbaa -> abbaaabbbaba
babbaaaba -> abbaaabbbabbbaaabbbabba
babbaaaa -> abbaaabbbabbbaaabbbaba

# < a,b | babbaaabbbbabba=a >
babbaaabbbbabba -> a
babbaaabbbbaba -> abbaaabbbbabba
babbaaabbba -> aaabbbbabba
babbaaabbbbaa -> abbaaabbbbaba
babbaaabba -> aaabbbbaba
babbaaaba -> aaabbbbaa
babbaaaa -> aaabbbbaabbaaabbbbabba

# < a,b | babbaabaababbba=a >
babbaabaababbba -> a
babbaabaababba -> abbaabaababbba
babbaabaababa -> abbaabaababba
babbaabaaa -> abbaabaababbbaabaababbba
babbaabaabaa -> abbaabaababa

# < a,b | babbaabababbaba=a >
babbaabababbaba -> a
babbaabababbaa -> abbaabababbaba
babbaabaa -> abbaabababbababababbaba

# < a,b | babbaabababbbba=a >
babbaabababbbba -> a
babbaabababbba -> abbaabababbbba
babbaabababba -> abbaabababbba
babbaabababa -> abbaabababba
babbaabaa -> abbaabababbbaabababbbba
babbaababaa -> abbaabababa

# < a,b | babbaababbaabba=a >
babbaababbaabba -> a
babbaababbaaba -> abbaababbaabba
babbaaa -> abbaababbaabbabbaabba

# < a,b | babbaababbabbaa=a >
babbaababbabbaa -> a
babbaababa -> ababbabbaa
babbaabaa -> ababbabbaabbaababbabbaa

# < a,b | babbaababbabbba=a >
babbaababbabbba -> a
babbaababbabba -> abbaababbabbba
babbaababbaba -> abbaababbabba
babbaababa -> abbaababbabbbaababbabbba
babbaababbaa -> abbaababbaba
babbaabaa -> abbaababbabbbaababbabba
babbaaa -> abbaababbabababbabbba

# < a,b | babbaababbbbbba=a >
babbaababbbbbba -> a
babbaababbbbba -> abbaababbbbbba
babbaababbbba -> abbaababbbbba
babbaababbba -> abbaababbbba
babbaababba -> abbaababbba
babbaababa -> abbaababba
babbaaa -> abbaababbbaababbbbbba
babbaabaa -> abbaababa

# < a,b | babbaabbababbba=a >
babbaabbababbba -> a
babbaabbababba -> abbaabbababbba
babbaabbababa -> abbaabbababba
babbaabbaa -> abbaabbababbbaabbababbba
babbaabbabaa -> abbaabbababa

# < a,b | babbaabbabbabba=a >
babbaabbabbabba -> a
babbaabbabbaba -> abbaabbabbabba
babbaabbaba -> aabbabbabba
babbaabbabbaa -> abbaabbabbaba
babbaabbaa -> aabbabbaba
babbaaba -> abbaabbabbababbabbabba
babbaaa -> abbaabbabbababbabbaba

# < a,b | babbaabbabbbbba=a >
babbaabbabbbbba -> a
babbaabbabbbba -> abbaabbabbbbba
babbaabbabbba -> abbaabbabbbba
babbaabbabba -> abbaabbabbba
babbaabbaba -> abbaabbabba
babbaaba -> abbaabbabbbaabbabbbbba
babbaabbaa -> abbaabbaba
babbaaa -> abbaabbabbbaabbabbbba

# < a,b | babbaabbbabbaba=a >
babbaabbbabbaba -> a
babbaabbbabbaa -> abbaabbbabbaba
babbaabba -> abbaabbbabbababbbabbaba
babbaaba -> abbaabbbabbababbbabbaa
babbaaa -> abbaabbbabbabababbbabbabaabbbabbaba

# < a,b | babbaabbbabbbba=a >
babbaabbbabbbba -> a
babbaabbbabbba -> abbaabbbabbbba
babbaabbbabba -> abbaabbbabbba
babbaabbbaba -> abbaabbbabba
babbaabba -> abbaabbbabbbaabbbabbbba
babbaabbbaa -> abbaabbbaba
babbaaba -> abbaabbbabbbaabbbabbba
babbaaa -> abbaabbbabbbaabbbabba

# < a,b | babbaabbbbabbba=a >
babbaabbbbabbba -> a
babbaabbbbabba -> abbaabbbbabbba
babbaabbbbaba -> abbaabbbbabba
babbaabbba -> abbaabbbbabbbaabbbbabbba
babbaabbbbaa -> abbaabbbbaba
babbaabba -> abbaabbbbabbbaabbbbabba
babbaaba -> abbaabbbbabbbaabbbbaba
babbaaa -> abbaabbbbabbbaabbbbaa

# < a,b | babbaabbbbbabba=a >
babbaabbbbbabba -> a
babbaabbbbbaba -> abbaabbbbbabba
babbaabbbba -> aabbbbbabba
babbaabbbbbaa -> abbaabbbbbaba
babbaabbba -> aabbbbbaba
babbaabba -> aabbbbbaa
babbaaba -> aabbbbbaabbaabbbbbabba
babbaaa -> aabbbbbaabbaabbbbbaba

# < a,b | babbabaaababbba=a >
babbabaaababbba -> a
babbabaaababba -> abbabaaababbba
babbabaaababa -> abbabaaababba
babbabaaaa -> abbabaaababbbabaaababbba
babbabaaabaa -> abbabaaababa

# < a,b | babbabaababbbba=a >
babbabaababbbba -> a
babbabaababbba -> abbabaababbbba
babbabaababba -> abbabaababbba
babbabaababa -> abbabaababba
babbabaaa -> abbabaababbbabaababbbba
babbabaabaa -> abbabaababa

# < a,b | babbabaabbabbba=a >
babbabaabbabbba -> a
babbabaabbabba -> abbabaabbabbba
babbabaabbaba -> abbabaabbabba
babbabaaba -> abbabaabbabbbabaabbabbba
babbabaabbaa -> abbabaabbaba
babbabaaa -> abbabaabbabbbabaabbabba

# < a,b | babbababababbba=a >
babbababababbba -> a
babbababababba -> abbababababbba
babbababababa -> abbababababba
babbababaa -> abbababababbbababababbba
babbabababaa -> abbababababa

# < a,b | babbabababbabba=a >
babbabababbabba -> a
babbabababbaba -> abbabababbabba
babbabababa -> abababbabba
babbabababbaa -> abbabababbaba
babbabaa -> abbabababbabbababbabba
babbababaa -> abababbaba

# < a,b | babbabababbbbba=a >
babbabababbbbba -> a
babbabababbbba -> abbabababbbbba
babbabababbba -> abbabababbbba
babbabababba -> abbabababbba
babbabababa -> abbabababba
babbabaa -> abbabababbbabababbbbba
babbababaa -> abbabababa

# < a,b | babbababbabbbba=a >
babbababbabbbba -> a
babbababbabbba -> abbababbabbbba
babbababbabba -> abbababbabbba
babbababbaba -> abbababbabba
babbababa -> abbababbabbbababbabbbba
babbaa -> abbababbabbabbabbbba
babbabaa -> abbababbabbbababbabbba

# < a,b | babbababbbabbba=a >
babbababbbabbba -> a
babbababbbabba -> abbababbbabbba
babbababbbaba -> abbababbbabba
babbababba -> abbababbbabbbababbbabbba
babbababbbaa -> abbababbbaba
babbababa -> abbababbbabbbababbbabba
babbaa -> abbababbbabbbababbbabbbababbbabbba
babbabaa -> abbababbbabbbababbbaba

# < a,b | babbababbbbabba=a >
babbababbbbabba -> a
babbababbbbaba -> abbababbbbabba
babbababbba -> ababbbbabba
babbababbbbaa -> abbababbbbaba
babbababba -> ababbbbaba
babbababa -> ababbbbaa
babbaa -> ababbbbabababbbbabba
babbabaa -> ababbbbaabbababbbbabba

# < a,b | babbababbbbbbba=a >
babbababbbbbbba -> a
babbababbbbbba -> abbababbbbbbba
babbababbbbba -> abbababbbbbba
babbababbbba -> abbababbbbba
babbababbba -> abbababbbba
babbababba -> abbababbba
babbababa -> abbababba
babbaa -> abbababbbababbbbbbba
babbabaa -> abbababa

# < a,b | babbabbaababbba=a >
babbabbaababbba -> a
babbabbaababba -> abbabbaababbba
babbabbaababa -> abbabbaababba
babbabbaaa -> abbabbaababbbabbaababbba
babbabbaabaa -> abbabbaababa

# < a,b | babbabbababbbba=a >
babbabbababbbba -> a
babbabbababbba -> abbabbababbbba
babbabbababba -> abbabbababbba
babbabbababa -> abbabbababba
babbabbaa -> abbabbababbbabbababbbba
babbabbabaa -> abbabbababa

# < a,b | babbabbabbabbba=a >
babbabbabbabbba -> a
babbabbabbabba -> abbabbabbabbba
baba -> abbabbabbabbbabbba
baa -> abbabbabbabbbabba

# < a,b | babbabbabbbabba=a >
babbabbabbbabba -> a
babbabbabba -> abbabbbabba
baba -> abbabbbabbabbbabba
baa -> ababbbabbabbbabba

# < a,b | babbabbabbbbbba=a >
babbabbabbbbbba -> a
babbabbabbbbba -> abbabbabbbbbba
babbabbabbbba -> abbabbabbbbba
babbabbabbba -> abbabbabbbba
babbabbabba -> abbabbabbba
baba -> abbabbabbbabbbbbba
baa -> abbabbabbbabbbbba

# < a,b | babbabbbababbba=a >
babbabbbababbba -> a
babbabbbababba -> abbabbbababbba
babbabbbababa -> abbabbbababba
babbabbbaa -> abbabbbababbbabbbababbba
babbabbbabaa -> abbabbbababa

# < a,b | babbabbbabbbbba=a >
babbabbbabbbbba -> a
babbabbbabbbba -> abbabbbabbbbba
babbabbbabbba -> abbabbbabbbba
babbabbbabba -> abbabbbabbba
babbabba -> abbabbbabbbabbbabbbbba
baba -> abbabbbabbbabbbabbbbbabbbabbbbba
baa -> abbabbbabbbabbbabbbbbabbbabbbba

# < a,b | babbabbbbabbbba=a >
babbabbbbabbbba -> a
babbabbbbabbba -> abbabbbbabbbba
babbabbbbabba -> abbabbbbabbba
babbabbba -> abbabbbbabbbabbbbabbbba
babbabba -> abbabbbbabbbabbbbabbba
baba -> abbabbbbabbbabbbbabbbabbbbabbbba
baa -> abbabbbbabbbabbbbabbbabbbbabbba

# < a,b | babbabbbbbbbbba=a >
babbabbbbbbbbba -> a
babbabbbbbbbba -> abbabbbbbbbbba
babbabbbbbbba -> abbabbbbbbbba
babbabbbbbba -> abbabbbbbbba
babbabbbbba -> abbabbbbbba
babbabbbba -> abbabbbbba
babbabbba -> abbabbbba
babbabba -> abbabbba
baba -> abbabbbabbbbbbbbba
baa -> abbabbbabbbbbbbba

# < a,b | babbbaaababbbba=a >
babbbaaababbbba -> a
babbbaaababbba -> abbbaaababbbba
babbbaaababba -> abbbaaababbba
babbbaaaa -> abbbaaababbbbaaababbbba
babbbaaababa -> abbbaaababba
babbbaaabaa -> abbbaaababa

# < a,b | babbbaababbbaba=a >
babbbaababbbaba -> a
babbbaababbbaa -> abbbaababbbaba
babbbaaa -> abbbaababbbabababbbaba

# < a,b | babbbaababbbbba=a >
babbbaababbbbba -> a
babbbaababbbba -> abbbaababbbbba
babbbaababbba -> abbbaababbbba
babbbaababba -> abbbaababbba
babbbaaa -> abbbaababbbbaababbbbba
babbbaababa -> abbbaababba
babbbaabaa -> abbbaababa

# < a,b | babbbaabbabbbaa=a >
babbbaabbabbbaa -> a
babbbaaba -> abbabbbaa
babbbaaa -> abbabbbaabbbaabbabbbaa

# < a,b | babbbaabbabbbba=a >
babbbaabbabbbba -> a
babbbaabbabbba -> abbbaabbabbbba
babbbaabbabba -> abbbaabbabbba
babbbaaba -> abbbaabbabbbbaabbabbbba
babbbaabbaba -> abbbaabbabba
babbbaaa -> abbbaabbabbbbaabbabbba
babbbaabbaa -> abbbaabbaba

# < a,b | babbbabababbbba=a >
babbbabababbbba -> a
babbbabababbba -> abbbabababbbba
babbbabababba -> abbbabababbba
babbbabaa -> abbbabababbbbabababbbba
babbbabababa -> abbbabababba
babbbababaa -> abbbabababa

# < a,b | babbbababbbabba=a >
babbbababbbabba -> a
babbbababbbaba -> abbbababbbabba
babbbaa -> abbbababbbabbabbbabba

# < a,b | babbbababbbbbba=a >
babbbababbbbbba -> a
babbbababbbbba -> abbbababbbbbba
babbbababbbba -> abbbababbbbba
babbbababbba -> abbbababbbba
babbbababba -> abbbababbba
babbbaa -> abbbababbbbababbbbbba
babbbababa -> abbbababba
babbbabaa -> abbbababa

# < a,b | babbbabbabbbbba=a >
babbbabbabbbbba -> a
babbbabbabbbba -> abbbabbabbbbba
babbbabbabbba -> abbbabbabbbba
babbbabbabba -> abbbabbabbba
babbbaba -> abbbabbabbbbabbabbbbba
babbbabbaba -> abbbabbabba
babbbaa -> abbbabbabbbbabbabbbba
babbbabbaa -> abbbabbaba

# < a,b | babbbabbbabbbba=a >
babbbabbbabbbba -> a
babbbabbbabbba -> abbbabbbabbbba
babba -> abbbabbbabbbbabbbba
baba -> abbbabbbabbbbabbba
baa -> ababbbabbbbabbbba

# < a,b | babbbabbbbbbbba=a >
babbbabbbbbbbba -> a
babbbabbbbbbba -> abbbabbbbbbbba
babbbabbbbbba -> abbbabbbbbbba
babbbabbbbba -> abbbabbbbbba
babbbabbbba -> abbbabbbbba
babbbabbba -> abbbabbbba
babba -> abbbabbbbabbbbbbbba
baba -> abbbabbbbabbbbbbba
baa -> abbbabbbbabbbbbba

# < a,b | babbbbababbbbba=a >
babbbbababbbbba -> a
babbbbababbbba -> abbbbababbbbba
babbbbababbba -> abbbbababbbba
babbbbaa -> abbbbababbbbbababbbbba
babbbbababba -> abbbbababbba
babbbbababa -> abbbbababba
babbbbabaa -> abbbbababa

# < a,b | babbbbabbbbbbba=a >
babbbbabbbbbbba -> a
babbbbabbbbbba -> abbbbabbbbbbba
babbbbabbbbba -> abbbbabbbbbba
babbbbabbbba -> abbbbabbbbba
babbba -> abbbbabbbbbabbbbbbba
babba -> abbbbabbbbbabbbbbba
baba -> abbbbabbbbbabbbbba
baa -> abbbbabbbbbabbbba

# < a,b | babbbbbabbbbbba=a >
babbbbbabbbbbba -> a
babbbbbabbbbba -> abbbbbabbbbbba
babbbba -> abbbbbabbbbbbabbbbbba
babbba -> abbbbbabbbbbbabbbbba
babba -> abbbabbbbbbabbbbbba
baba -> abbbabbbbbbabbbbba
baa -> ababbbbbbabbbbbba

# < a,b | bbaaaaaaabbabba=a >
bbaaaaaaabbabba -> a
bbaaaaaaabbaa -> aaaaaaabbabba
bbaaaaaaaa -> aaaaaaabbabbaaaaaabbabba

# < a,b | bbaaaaaabbaabba=a >
bbaaaaaabbaabba -> a
bbaaaaaabbaaa -> aaaaaabbaabba
bbaaaaaaa -> aaaaaabbaabbaaaabbaabba

# < a,b | bbaaaaaabbbabba=a >
bbaaaaaabbbabba -> a
bbaaaaaabbbaa -> aaaaaabbbabba
bbaaaaaaba -> aaaaaabbbabbaaaaabbbabba

# < a,b | bbaaaaaabbbbbaa=a >
bbaaaaaabbbbbaa -> a
bbaaaaaabbba -> aaaaabbbbbaa
bbaaaaaaba -> aaaaabbbbbaaaaaaabbbbbaa

# < a,b | bbaaaaababbabba=a >
bbaaaaababbabba -> a
bbaaaaababbaa -> aaaaababbabba
bbaaaaabaa -> aaaaababbabbaaaababbabba

# < a,b | bbaaaaababbbbaa=a >
bbaaaaababbbbaa -> a
bbaaaaababba -> aaaababbbbaa
bbaaaaabaa -> aaaababbbbaaaaaababbbbaa

# < a,b | bbaaaaabbaaabba=a >
bbaaaaabbaaabba -> a
bbaaaaabbaaaa -> aaaaabbaaabba
bbaaaaaa -> aaaaabbaaabbaabbaaabba

# < a,b | bbaaaaabbaabbaa=a >
bbaaaaabbaabbaa -> a
bbaaaaabbaaa -> aaaabbaabbaa
bbaaaaaa -> aaaabbaabbaaaabbaabbaa

# < a,b | bbaaaaabbabbbba=a >
bbaaaaabbabbbba -> a
bbaaaaabbabba -> aaaaabbabbbba
bbaaaaabbaa -> aaaaabbabba
bbaaaaaa -> aaaaabbabbaaaabbabbbba

# < a,b | bbaaaaabbbaabba=a >
bbaaaaabbbaabba -> a
bbaaaaabbbaaa -> aaaaabbbaabba
bbaaaaaba -> aaaaabbbaabbaaabbbaabba

# < a,b | bbaaaaabbbbabba=a >
bbaaaaabbbbabba -> a
bbaaaaabbbbaa -> aaaaabbbbabba
bbaaaaabba -> aaaaabbbbabbaaaabbbbabba
bbaaaaaa -> aaaaabbbbabbaaaabbbbaa

# < a,b | bbaaaaabbbbbaaa=a >
bbaaaaabbbbbaaa -> a
bbaaaaabbba -> aaabbbbbaaa
bbaaaaaba -> aaabbbbbaaaaaaabbbbbaaa

# < a,b | bbaaaabaabbabba=a >
bbaaaabaabbabba -> a
bbaaaabaabbaa -> aaaabaabbabba
bbaaaabaaa -> aaaabaabbabbaaabaabbabba

# < a,b | bbaaaabaabbbbaa=a >
bbaaaabaabbbbaa -> a
bbaaaabaabba -> aaabaabbbbaa
bbaaaabaaa -> aaabaabbbbaaaaabaabbbbaa

# < a,b | bbaaaababbaabba=a >
bbaaaababbaabba -> a
bbaaaababbaaa -> aaaababbaabba
bbaaaabaa -> aaaababbaabbaababbaabba

# < a,b | bbaaaababbbabba=a >
bbaaaababbbabba -> a
bbaaaababbbaa -> aaaababbbabba
bbaaaababa -> aaaababbbabbaaababbbabba

# < a,b | bbaaaababbbbaaa=a >
bbaaaababbbbaaa -> a
bbaaaababba -> aababbbbaaa
bbaaaabaa -> aababbbbaaaaaababbbbaaa

# < a,b | bbaaaababbbbbaa=a >
bbaaaababbbbbaa -> a
bbaaaababbba -> aaababbbbbaa
bbaaaababa -> aaababbbbbaaaaababbbbbaa

# < a,b | bbaaaabbaaabbaa=a >
bbaaaabbaaabbaa -> a
bbaaaabbaaaa -> aaabbaaabbaa
bbaaaaa -> aaabbaaabbaabbaaabbaa

# < a,b | bbaaaabbaabbbba=a >
bbaaaabbaabbbba -> a
bbaaaabbaabba -> aaaabbaabbbba
bbaaaabbaaa -> aaaabbaabba
bbaaaaa -> aaaabbaabbaabbaabbbba

# < a,b | bbaaaabbabbabba=a >
bbaaaabbabbabba -> a
bbaaaabbabbaa -> aaaabbabbabba
bbaaaabbaa -> aaaabbabbabbaaabbabbabba
bbaaaaa -> aaaabbabbabbaaabbabbabbaaabbabbabba

# < a,b | bbaaaabbbaaabba=a >
bbaaaabbbaaabba -> a
bbaaaabbbaaaa -> aaaabbbaaabba
bbaaaaba -> aaaabbbaaabbabbbaaabba

# < a,b | bbaaaabbbaabbaa=a >
bbaaaabbbaabbaa -> a
bbaaaabbbaaa -> aaabbbaabbaa
bbaaaaba -> aaabbbaabbaaabbbaabbaa

# < a,b | bbaaaabbbabbaaa=a >
bbaaaabbbabbaaa -> a
bbaaaabbbaa -> aabbbabbaaa
bbaaaaba -> aabbbabbaaaaabbbabbaaa

# < a,b | bbaaaabbbabbbba=a >
bbaaaabbbabbbba -> a
bbaaaabbbabba -> aaaabbbabbbba
bbaaaabbbaa -> aaaabbbabba
bbaaaaba -> aaaabbbabbaaabbbabbbba

# < a,b | bbaaaabbbbaabba=a >
bbaaaabbbbaabba -> a
bbaaaabbbbaaa -> aaaabbbbaabba
bbaaaabba -> aaaabbbbaabbaabbbbaabba
bbaaaaa -> aaaabbbbaabbaabbbbaaa

# < a,b | bbaaaabbbbbaaaa=a >
bbaaaabbbbbaaaa -> a
bbaaaabbba -> abbbbbaaaa
bbaaaaba -> abbbbbaaaaaaabbbbbaaaa

# < a,b | bbaaaabbbbbabba=a >
bbaaaabbbbbabba -> a
bbaaaabbbbbaa -> aaaabbbbbabba
bbaaaabbba -> aaaabbbbbabbaaabbbbbabba
bbaaaaba -> aaaabbbbbabbaaabbbbbaa

# < a,b | bbaaaabbbbbbbaa=a >
bbaaaabbbbbbbaa -> a
bbaaaabbbbba -> aaabbbbbbbaa
bbaaaabbba -> aaabbbbbbbaaaaabbbbbbbaa
bbaaaaba -> aaabbbbbbbaaaaabbbbbbbaaaaabbbbbbbaa

# < a,b | bbaaabaaabbabba=a >
bbaaabaaabbabba -> a
bbaaabaaabbaa -> aaabaaabbabba
bbaaabaaaa -> aaabaaabbabbaabaaabbabba

# < a,b | bbaaabaaabbbbaa=a >
bbaaabaaabbbbaa -> a
bbaaabaaabba -> aabaaabbbbaa
bbaaabaaaa -> aabaaabbbbaaaabaaabbbbaa

# < a,b | bbaaabaabbaabba=a >
bbaaabaabbaabba -> a
bbaaabaabbaaa -> aaabaabbaabba
bbaaabaaa -> aaabaabbaabbabaabbaabba

# < a,b | bbaaabaabbbabba=a >
bbaaabaabbbabba -> a
bbaaabaabbbaa -> aaabaabbbabba
bbaaabaaba -> aaabaabbbabbaabaabbbabba

# < a,b | bbaaabaabbbbaaa=a >
bbaaabaabbbbaaa -> a
bbaaabaabba -> abaabbbbaaa
bbaaabaaa -> abaabbbbaaaaabaabbbbaaa

# < a,b | bbaaabaabbbbbaa=a >
bbaaabaabbbbbaa -> a
bbaaabaabbba -> aabaabbbbbaa
bbaaabaaba -> aabaabbbbbaaaabaabbbbbaa

# < a,b | bbaaabababbabba=a >
bbaaabababbabba -> a
bbaaabababbaa -> aaabababbabba
bbaaababaa -> aaabababbabbaabababbabba

# < a,b | bbaaabababbbbaa=a >
bbaaabababbbbaa -> a
bbaaabababba -> aabababbbbaa
bbaaababaa -> aabababbbbaaaabababbbbaa

# < a,b | bbaaababbaabbaa=a >
bbaaababbaabbaa -> a
bbaaababbaaa -> aababbaabbaa
bbaaabaa -> aababbaabbaababbaabbaa

# < a,b | bbaaababbabbaaa=a >
bbaaababbabbaaa -> a
bbaaababbaa -> ababbabbaaa
bbaaabaa -> ababbabbaaaababbabbaaa

# < a,b | bbaaababbabbbba=a >
bbaaababbabbbba -> a
bbaaababbabba -> aaababbabbbba
bbaaababbaa -> aaababbabba
bbaaabaa -> aaababbabbaababbabbbba

# < a,b | bbaaababbbaabba=a >
bbaaababbbaabba -> a
bbaaababbbaaa -> aaababbbaabba
bbaaababa -> aaababbbaabbababbbaabba

# < a,b | bbaaababbbbabba=a >
bbaaababbbbabba -> a
bbaaababbbbaa -> aaababbbbabba
bbaaababba -> aaababbbbabbaababbbbabba
bbaaabaa -> aaababbbbabbaababbbbaa

# < a,b | bbaaababbbbbaaa=a >
bbaaababbbbbaaa -> a
bbaaababbba -> ababbbbbaaa
bbaaababa -> ababbbbbaaaaababbbbbaaa

# < a,b | bbaaababbbbbbaa=a >
bbaaababbbbbbaa -> a
bbaaababbbba -> aababbbbbbaa
bbaaababba -> aababbbbbbaaaababbbbbbaa
bbaaabaa -> aababbbbbbaaaababbbbbbaaaababbbbbbaa

# < a,b | bbaaabbaaabbbba=a >
bbaaabbaaabbbba -> a
bbaaabbaaabba -> aaabbaaabbbba
bbaaaa -> aaabbaaabbbbaaabbbba

# < a,b | bbaaabbaabbabba=a >
bbaaabbaabbabba -> a
bbaaabbaabbaa -> aaabbaabbabba
bbaaabbaaa -> aaabbaabbabbaabbaabbabba
bbaaaa -> aaabbaabbabbaabbaabbabbabbaabbabba

# < a,b | bbaaabbabbaabba=a >
bbaaabbabbaabba -> a
bbaaabbabbaaa -> aaabbabbaabba
bbaaabbaa -> aaabbabbaabbabbabbaabba
bbaaaa -> aaabbabbaabbabbabbaabbaabbabbaabba

# < a,b | bbaaabbabbbabba=a >
bbaaabbabbbabba -> a
bbaaabbabbbaa -> aaabbabbbabba
bbaaabbaba -> aaabbabbbabbaabbabbbabba

# < a,b | bbaaabbabbbbbaa=a >
bbaaabbabbbbbaa -> a
bbaaabbabbba -> aabbabbbbbaa
bbaaabbaba -> aabbabbbbbaaaabbabbbbbaa

# < a,b | bbaaabbabbbbbba=a >
bbaaabbabbbbbba -> a
bbaaabbabbbba -> aaabbabbbbbba
bbaaabbabba -> aaabbabbbba
bbaaabbaa -> aaabbabba
bbaaaa -> aaabbabbaabbabbbbbba

# < a,b | bbaaabbbaabbbba=a >
bbaaabbbaabbbba -> a
bbaaabbbaabba -> aaabbbaabbbba
bbaaabbbaaa -> aaabbbaabba
bbaaaba -> aaabbbaabbabbbaabbbba

# < a,b | bbaaabbbabbabba=a >
bbaaabbbabbabba -> a
bbaaabbbabbaa -> aaabbbabbabba
bbaaabbbaa -> aaabbbabbabbaabbbabbabba
bbaaaba -> aaabbbabbabbaabbbabbabbaabbbabbabba

# < a,b | bbaaabbbabbbbaa=a >
bbaaabbbabbbbaa -> a
bbaaabbbabba -> aabbbabbbbaa
bbaaabbbaa -> aabbbabbbbaaaabbbabbbbaa
bbaaaba -> aabbbabbbbaaaabbbabba

# < a,b | bbaaabbbbabbbba=a >
bbaaabbbbabbbba -> a
bbaaabbbbabba -> aaabbbbabbbba
bbaaabbbbaa -> aaabbbbabba
bbaaabba -> aaabbbbabbaabbbbabbbba
bbaaaa -> aaabbbbabbaabbbbabba

# < a,b | bbaaabbbbbaabba=a >
bbaaabbbbbaabba -> a
bbaaabbbbbaaa -> aaabbbbbaabba
bbaaabbba -> aaabbbbbaabbabbbbbaabba
bbaaaba -> aaabbbbbaabbabbbbbaaa

# < a,b | bbaaabbbbbabbaa=a >
bbaaabbbbbabbaa -> a
bbaaabbbbbaa -> aabbbbbabbaa
bbaaabbba -> aabbbbbaa
bbaaaba -> aabbbbbaaaabbbbbabbaa

# < a,b | bbaaabbbbbbbaaa=a >
bbaaabbbbbbbaaa -> a
bbaaabbbbba -> abbbbbbbaaa
bbaaabbba -> abbbbbbbaaaaabbbbbbbaaa
bbaaaba -> abbbbbbbaaaaabbbbbbbaaaaabbbbbbbaaa

# < a,b | bbaabaaaabbabba=a >
bbaabaaaabbabba -> a
bbaabaaaabbaa -> aabaaaabbabba
bbaabaaaaa -> aabaaaabbabbabaaaabbabba

# < a,b | bbaabaaaabbbbaa=a >
bbaabaaaabbbbaa -> a
bbaabaaaabba -> abaaaabbbbaa
bbaabaaaaa -> abaaaabbbbaaabaaaabbbbaa

# < a,b | bbaabaaabbbabba=a >
bbaabaaabbbabba -> a
bbaabaaabbbaa -> aabaaabbbabba
bbaabaaaba -> aabaaabbbabbabaaabbbabba

# < a,b | bbaabaaabbbbbaa=a >
bbaabaaabbbbbaa -> a
bbaabaaabbba -> abaaabbbbbaa
bbaabaaaba -> abaaabbbbbaaabaaabbbbbaa

# < a,b | bbaabaababbabba=a >
bbaabaababbabba -> a
bbaabaababbaa -> aabaababbabba
bbaabaabaa -> aabaababbabbabaababbabba

# < a,b | bbaabaababbbbaa=a >
bbaabaababbbbaa -> a
bbaabaababba -> abaababbbbaa
bbaabaabaa -> abaababbbbaaabaababbbbaa

# < a,b | bbaabaabbaabbba=a >
bbaabaabbaabbba -> a
bbaabaabbaaba -> aabaabbaabbba
bbaabaaa -> aabaabbaabbbaabbaabbba

# < a,b | bbaabaabbabbbba=a >
bbaabaabbabbbba -> a
bbaabaabbabba -> aabaabbabbbba
bbaabaabbaa -> aabaabbabba
bbaabaaa -> aabaabbabbabaabbabbbba

# < a,b | bbaabaabbbbaaba=a >
bbaabaabbbbaaba -> a
bbaabaabba -> aabbbbaaba
bbaabaaa -> aabbbbaabaabaabbbbaaba

# < a,b | bbaabaabbbbabba=a >
bbaabaabbbbabba -> a
bbaabaabbbbaa -> aabaabbbbabba
bbaabaabba -> aabaabbbbabbabaabbbbabba
bbaabaaa -> aabaabbbbabbabaabbbbaa

# < a,b | bbaabaabbbbbbaa=a >
bbaabaabbbbbbaa -> a
bbaabaabbbba -> abaabbbbbbaa
bbaabaabba -> abaabbbbbbaaabaabbbbbbaa
bbaabaaa -> abaabbbbbbaaabaabbbbbbaaabaabbbbbbaa

# < a,b | bbaababaabbabba=a >
bbaababaabbabba -> a
bbaababaabbaa -> aababaabbabba
bbaababaaa -> aababaabbabbababaabbabba

# < a,b | bbaababaabbbbaa=a >
bbaababaabbbbaa -> a
bbaababaabba -> ababaabbbbaa
bbaababaaa -> ababaabbbbaaababaabbbbaa

# < a,b | bbaabababbbabba=a >
bbaabababbbabba -> a
bbaabababbbaa -> aabababbbabba
bbaabababa -> aabababbbabbabababbbabba

# < a,b | bbaabababbbbbaa=a >
bbaabababbbbbaa -> a
bbaabababbba -> abababbbbbaa
bbaabababa -> abababbbbbaaabababbbbbaa

# < a,b | bbaababbaabbbaa=a >
bbaababbaabbbaa -> a
bbaababbaaba -> ababbaabbbaa
bbaabaa -> ababbaabbbaabbaabbbaa

# < a,b | bbaababbabbaaba=a >
bbaababbabbaaba -> a
bbaababbaa -> abbabbaaba
bbaabaa -> abbabbaabababbabbaaba

# < a,b | bbaababbabbabba=a >
bbaababbabbabba -> a
bbaababbabbaa -> aababbabbabba
bbaababbaa -> aababbabbabbababbabbabba
bbaabaa -> aababbabbabbababbabbabbababbabbabba

# < a,b | bbaababbabbbbaa=a >
bbaababbabbbbaa -> a
bbaababbabba -> ababbabbbbaa
bbaababbaa -> ababbabbbbaaababbabbbbaa
bbaabaa -> ababbabbbbaaababbabba

# < a,b | bbaababbbaabbba=a >
bbaababbbaabbba -> a
bbaababbbaaba -> aababbbaabbba
bbaababa -> aababbbaabbbabbbaabbba

# < a,b | bbaababbbabbbba=a >
bbaababbbabbbba -> a
bbaababbbabba -> aababbbabbbba
bbaababbbaa -> aababbbabba
bbaababa -> aababbbabbababbbabbbba

# < a,b | bbaababbbbabbaa=a >
bbaababbbbabbaa -> a
bbaababbbbaa -> ababbbbabbaa
bbaababba -> ababbbbaa
bbaabaa -> ababbbbaaababbbbabbaa

# < a,b | bbaababbbbbaaba=a >
bbaababbbbbaaba -> a
bbaababbba -> abbbbbaaba
bbaababa -> abbbbbaabaababbbbbaaba

# < a,b | bbaababbbbbabba=a >
bbaababbbbbabba -> a
bbaababbbbbaa -> aababbbbbabba
bbaababbba -> aababbbbbabbababbbbbabba
bbaababa -> aababbbbbabbababbbbbaa

# < a,b | bbaababbbbbbbaa=a >
bbaababbbbbbbaa -> a
bbaababbbbba -> ababbbbbbbaa
bbaababbba -> ababbbbbbbaaababbbbbbbaa
bbaababa -> ababbbbbbbaaababbbbbbbaaababbbbbbbaa

# < a,b | bbaabbaaabbabba=a >
bbaabbaaabbabba -> a
bbaabbaaabbaa -> aabbaaabbabba
bbaabbaaaa -> aabbaaabbabbabbaaabbabba

# < a,b | bbaabbaaabbbbaa=a >
bbaabbaaabbbbaa -> a
bbaabbaaabba -> abbaaabbbbaa
bbaabbaaaa -> abbaaabbbbaaabbaaabbbbaa

# < a,b | bbaabbaabbabbaa=a >
bbaabbaabbabbaa -> a
bbaabbaabbaa -> abbaabbabbaa
bbaaa -> abbaabbabbaabbabbaa

# < a,b | bbaabbaabbbabba=a >
bbaabbaabbbabba -> a
bbaabbaabbbaa -> aabbaabbbabba
bbaabbaaba -> aabbaabbbabbabbaabbbabba

# < a,b | bbaabbaabbbbbaa=a >
bbaabbaabbbbbaa -> a
bbaabbaabbba -> abbaabbbbbaa
bbaabbaaba -> abbaabbbbbaaabbaabbbbbaa

# < a,b | bbaabbaabbbbbba=a >
bbaabbaabbbbbba -> a
bbaabbaabbbba -> aabbaabbbbbba
bbaabbaabba -> aabbaabbbba
bbaaa -> aabbaabbbbaabbbbbba

# < a,b | bbaabbababbabba=a >
bbaabbababbabba -> a
bbaabbababbaa -> aabbababbabba
bbaabbabaa -> aabbababbabbabbababbabba

# < a,b | bbaabbababbbbaa=a >
bbaabbababbbbaa -> a
bbaabbababba -> abbababbbbaa
bbaabbabaa -> abbababbbbaaabbababbbbaa

# < a,b | bbaabbabbabbbba=a >
bbaabbabbabbbba -> a
bbaabbabbabba -> aabbabbabbbba
bbaabbabbaa -> aabbabbabba
bbaabbaa -> aabbabbabbabbabbabbbba
bbaaa -> aabbabbabbabbabbabbbbabbabbabbbba

# < a,b | bbaabbabbbbabba=a >
bbaabbabbbbabba -> a
bbaabbabbbbaa -> aabbabbbbabba
bbaabbabba -> aabbabbbbabbabbabbbbabba
bbaabbaa -> aabbabbbbabbabbabbbbaa
bbaaa -> aabbabbbbabbabbabba

# < a,b | bbaabbbaabbabba=a >
bbaabbbaabbabba -> a
bbaabbbaabbaa -> aabbbaabbabba
bbaabbbaaa -> aabbbaabbabbabbbaabbabba

# < a,b | bbaabbbaabbbbaa=a >
bbaabbbaabbbbaa -> a
bbaabbbaabba -> abbbaabbbbaa
bbaabbbaaa -> abbbaabbbbaaabbbaabbbbaa

# < a,b | bbaabbbaabbbbba=a >
bbaabbbaabbbbba -> a
bbaabbbaabbba -> aabbbaabbbbba
bbaaba -> aabbbaabbbbbaabbbbba

# < a,b | bbaabbbabbbabba=a >
bbaabbbabbbabba -> a
bbaabbbabbbaa -> aabbbabbbabba
bbaabbbaba -> aabbbabbbabbabbbabbbabba

# < a,b | bbaabbbabbbbbaa=a >
bbaabbbabbbbbaa -> a
bbaabbbabbba -> abbbabbbbbaa
bbaabbbaba -> abbbabbbbbaaabbbabbbbbaa

# < a,b | bbaabbbabbbbbba=a >
bbaabbbabbbbbba -> a
bbaabbbabbbba -> aabbbabbbbbba
bbaabbbabba -> aabbbabbbba
bbaabbbaa -> aabbbabba
bbaaba -> aabbbabbabbbabbbbbba

# < a,b | bbaabbbbabbabba=a >
bbaabbbbabbabba -> a
bbaabbbbabbaa -> aabbbbabbabba
bbaabbbbaa -> aabbbbabbabbabbbbabbabba
bbaabba -> aabbbbabbabbabbbbabbabbabbbbabbabba
bbaaa -> aabbbbabbabbabbbbabbabbabbbbabbaa

# < a,b | bbaabbbbbabbbba=a >
bbaabbbbbabbbba -> a
bbaabbbbbabba -> aabbbbbabbbba
bbaabbbbbaa -> aabbbbbabba
bbaabbba -> aabbbbbabbabbbbbabbbba
bbaaba -> aabbbbbabbabbbbbabba

# < a,b | bbaabbbbbbbabba=a >
bbaabbbbbbbabba -> a
bbaabbbbbbbaa -> aabbbbbbbabba
bbaabbbbba -> aabbbbbbbabbabbbbbbbabba
bbaabbba -> aabbbbbbbabbabbbbbbbaa
bbaaba -> aabbbbbbbabbabbbbbbbaaabbbbbbbabba

# < a,b | bbaabbbbbbbbbaa=a >
bbaabbbbbbbbbaa -> a
bbaabbbbbbba -> abbbbbbbbbaa
bbaabbbbba -> abbbbbbbbbaaabbbbbbbbbaa
bbaabbba -> abbbbbbbbbaaabbbbbbbbbaaabbbbbbbbbaa
bbaaba -> abbbbbbbbbaaabbbbbbbbbaaabbbbbbbbbaaabbbbbbbbbaa

# < a,b | bbabaaaabbabbba=a >
bbabaaaabbabbba -> a
bbabaaaabbaba -> abaaaabbabbba
bbabaaaaa -> abaaaabbabbbaaaabbabbba

# < a,b | bbabaaaabbbbaba=a >
bbabaaaabbbbaba -> a
bbabaaaabba -> aaaabbbbaba
bbabaaaaa -> aaaabbbbababaaaabbbbaba

# < a,b | bbabaaabbababba=a >
bbabaaabbababba -> a
bbabaaabbabaa -> abaaabbababba
bbabaaaa -> abaaabbababbaabbababba

# < a,b | bbabaaabbbabbba=a >
bbabaaabbbabbba -> a
bbabaaabbbaba -> abaaabbbabbba
bbabaaaba -> abaaabbbabbbaaabbbabbba

# < a,b | bbabaaabbbbabaa=a >
bbabaaabbbbabaa -> a
bbabaaabba -> aabbbbabaa
bbabaaaa -> aabbbbabaabaaabbbbabaa

# < a,b | bbabaaabbbbbaba=a >
bbabaaabbbbbaba -> a
bbabaaabbba -> aaabbbbbaba
bbabaaaba -> aaabbbbbababaaabbbbbaba

# < a,b | bbabaababbabbba=a >
bbabaababbabbba -> a
bbabaababbaba -> abaababbabbba
bbabaabaa -> abaababbabbbaababbabbba

# < a,b | bbabaababbbbaba=a >
bbabaababbbbaba -> a
bbabaababba -> aababbbbaba
bbabaabaa -> aababbbbababaababbbbaba

# < a,b | bbabaabbabbbbba=a >
bbabaabbabbbbba -> a
bbabaabbabbba -> abaabbabbbbba
bbabaabbaba -> abaabbabbba
bbabaaa -> abaabbabbbaabbabbbbba

# < a,b | bbabaabbbababba=a >
bbabaabbbababba -> a
bbabaabbbabaa -> abaabbbababba
bbabaaba -> abaabbbababbabbbababba

# < a,b | bbabaabbbbabbba=a >
bbabaabbbbabbba -> a
bbabaabbbbaba -> abaabbbbabbba
bbabaabba -> abaabbbbabbbaabbbbabbba
bbabaaa -> abaabbbbabbbaabbbbaba

# < a,b | bbabaabbbbbbaba=a >
bbabaabbbbbbaba -> a
bbabaabbbba -> aabbbbbbaba
bbabaabba -> aabbbbbbababaabbbbbbaba
bbabaaa -> aabbbbbbababaabbbbbbababaabbbbbbaba

# < a,b | bbababaabbabbba=a >
bbababaabbabbba -> a
bbababaabbaba -> ababaabbabbba
bbababaaa -> ababaabbabbbabaabbabbba

# < a,b | bbababaabbbbaba=a >
bbababaabbbbaba -> a
bbababaabba -> abaabbbbaba
bbababaaa -> abaabbbbabababaabbbbaba

# < a,b | bbabababbbabbba=a >
bbabababbbabbba -> a
bbabababbbaba -> abababbbabbba
bbabababa -> abababbbabbbababbbabbba

# < a,b | bbababbababbbba=a >
bbababbababbbba -> a
bbababbababba -> ababbababbbba
bbabaa -> ababbababbbbababbbba

# < a,b | bbababbabbabbba=a >
bbababbabbabbba -> a
bbababbabbaba -> ababbabbabbba
bbababbaa -> ababbabbabbbabbabbabbba

# < a,b | bbababbabbbbaba=a >
bbababbabbbbaba -> a
bbababbabba -> abbabbbbaba
bbababbaa -> abbabbbbabababbabbbbaba

# < a,b | bbababbbabbbbba=a >
bbababbbabbbbba -> a
bbababbbabbba -> ababbbabbbbba
bbababbbaba -> ababbbabbba
bbababa -> ababbbabbbabbbabbbbba

# < a,b | bbababbbbbabbba=a >
bbababbbbbabbba -> a
bbababbbbbaba -> ababbbbbabbba
bbababbba -> ababbbbbabbbabbbbbabbba
bbababa -> ababbbbbabbbabbbbbaba

# < a,b | bbabbaabbabbbba=a >
bbabbaabbabbbba -> a
bbabbaabbabba -> abbaabbabbbba
bbabbaabbaa -> abbaabbabba
bbabbaaa -> abbaabbabbbbaabbabbbba

# < a,b | bbabbabbbabbbba=a >
bbabbabbbabbbba -> a
bbabbabbbabba -> abbabbbabbbba
bbabbabbbaa -> abbabbbabba
bbabbaba -> abbabbbabbbbabbbabbbba

# < a,b | bbabbabbbbbbbba=a >
bbabbabbbbbbbba -> a
bbabbabbbbbba -> abbabbbbbbbba
bbabbabbbba -> abbabbbbbba
bbabbabba -> abbabbbba
bbaa -> abbabbbbabbbbbbbba

# < a,b | bbabbbabbbbbbba=a >
bbabbbabbbbbbba -> a
bbabbbabbbbba -> abbbabbbbbbba
bbabbbabbba -> abbbabbbbba
bbaba -> abbbabbbbbabbbbbbba

# < a,b | bbabbbbabbbbbba=a >
bbabbbbabbbbbba -> a
bbabbbbabbbba -> abbbbabbbbbba
bbabba -> abbbbabbbbbbabbbbbba
bbaa -> abbbbabbbbbbabbbba

# < a,b | bbbaaaabbbabbba=a >
bbbaaaabbbabbba -> a
bbbaaaabbbaa -> aaaabbbabbba
bbbaaaaa -> aaaabbbabbbaaabbbabbba

# < a,b | bbbaaabbbaabbba=a >
bbbaaabbbaabbba -> a
bbbaaabbbaaa -> aaabbbaabbba
bbbaaaa -> aaabbbaabbbabbbaabbba

# < a,b | bbbaaabbbbabbba=a >
bbbaaabbbbabbba -> a
bbbaaabbbbaa -> aaabbbbabbba
bbbaaaba -> aaabbbbabbbaabbbbabbba

# < a,b | bbbaaabbbbbbbaa=a >
bbbaaabbbbbbbaa -> a
bbbaaabbbba -> aabbbbbbbaa
bbbaaaba -> aabbbbbbbaaaabbbbbbbaa

# < a,b | bbbaababbbabbba=a >
bbbaababbbabbba -> a
bbbaababbbaa -> aababbbabbba
bbbaabaa -> aababbbabbbababbbabbba

# < a,b | bbbaababbbbbbaa=a >
bbbaababbbbbbaa -> a
bbbaababbba -> ababbbbbbaa
bbbaabaa -> ababbbbbbaaababbbbbbaa

# < a,b | bbbaabbbbbabbba=a >
bbbaabbbbbabbba -> a
bbbaabbbbbaa -> aabbbbbabbba
bbbaabba -> aabbbbbabbbabbbbbabbba

# < a,b | bbbaabbbbbbbbaa=a >
bbbaabbbbbbbbaa -> a
bbbaabbbbba -> abbbbbbbbaa
bbbaabba -> abbbbbbbbaaabbbbbbbbaa

# < a,b | bbbababbbabbbba=a >
bbbababbbabbbba -> a
bbbababbbaba -> ababbbabbbba
bbbabaa -> ababbbabbbbabbbabbbba

# < a,b | bbbababbbbbbaba=a >
bbbababbbbbbaba -> a
bbbababbba -> abbbbbbaba
bbbabaa -> abbbbbbabababbbbbbaba

# < a,b | bbbabbbabbbbbba=a >
bbbabbbabbbbbba -> a
bbbabbbabbba -> abbbabbbbbba
bbbaa -> abbbabbbbbbabbbbbba

03_shortlex.txt

# < a,b | ba=a >
ba -> a

# < a,b | baa=a >
baa -> a

# < a,b | bba=a >
bba -> a

# < a,b | baaa=a >
baaa -> a

# < a,b | baba=a >
baba -> a
baa -> aba

# < a,b | bbaa=a >
bbaa -> a

# < a,b | bbba=a >
bbba -> a

# < a,b | baaaa=a >
baaaa -> a

# < a,b | baaba=a >
baaba -> a
baaa -> aaba

# < a,b | babaa=a >
babaa -> a

# < a,b | babba=a >
babba -> a
baba -> abba
baa -> aba

# < a,b | bbaaa=a >
bbaaa -> a

# < a,b | bbaba=a >
bbaba -> a

# < a,b | bbbaa=a >
bbbaa -> a

# < a,b | bbbba=a >
bbbba -> a

# < a,b | baaaaa=a >
baaaaa -> a

# < a,b | baaaba=a >
baaaba -> a
baaaa -> aaaba

# < a,b | baabaa=a >
baabaa -> a
baaa -> abaa

# < a,b | baabba=a >
baabba -> a
baaba -> aabba
baaa -> aaba

# < a,b | babaaa=a >
babaaa -> a

# < a,b | bababa=a >
bababa -> a
baa -> aba

# < a,b | babbaa=a >
babbaa -> a

# < a,b | babbba=a >
babbba -> a
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaa=a >
bbaaaa -> a

# < a,b | bbaaba=a >
bbaaba -> a

# < a,b | bbabaa=a >
bbabaa -> a

# < a,b | bbabba=a >
bbabba -> a
bbaa -> abba

# < a,b | bbbaaa=a >
bbbaaa -> a

# < a,b | bbbaba=a >
bbbaba -> a

# < a,b | bbbbaa=a >
bbbbaa -> a

# < a,b | bbbbba=a >
bbbbba -> a

# < a,b | baaaaaa=a >
baaaaaa -> a

# < a,b | baaaaba=a >
baaaaba -> a
baaaaa -> aaaaba

# < a,b | baaabaa=a >
baaabaa -> a
baaaa -> aabaa

# < a,b | baaabba=a >
baaabba -> a
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaa=a >
baabaaa -> a

# < a,b | baabbba=a >
baabbba -> a
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaa=a >
babaaaa -> a

# < a,b | babaaba=a >
babaaba -> a
babaaa -> abaaba

# < a,b | bababaa=a >
bababaa -> a

# < a,b | babbaaa=a >
babbaaa -> a

# < a,b | babbaba=a >
babbaba -> a
babbaa -> abbaba

# < a,b | babbbaa=a >
babbbaa -> a

# < a,b | babbbba=a >
babbbba -> a
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaa=a >
bbaaaaa -> a

# < a,b | bbaaaba=a >
bbaaaba -> a

# < a,b | bbaabaa=a >
bbaabaa -> a

# < a,b | bbaabba=a >
bbaabba -> a
bbaaa -> aabba

# < a,b | bbabaaa=a >
bbabaaa -> a

# < a,b | bbababa=a >
bbababa -> a

# < a,b | bbabbaa=a >
bbabbaa -> a

# < a,b | bbabbba=a >
bbabbba -> a
bbaba -> abbba

# < a,b | bbbaaaa=a >
bbbaaaa -> a

# < a,b | bbbaaba=a >
bbbaaba -> a

# < a,b | bbbabaa=a >
bbbabaa -> a

# < a,b | bbbabba=a >
bbbabba -> a

# < a,b | bbbbaaa=a >
bbbbaaa -> a

# < a,b | bbbbaba=a >
bbbbaba -> a

# < a,b | bbbbbaa=a >
bbbbbaa -> a

# < a,b | bbbbbba=a >
bbbbbba -> a

# < a,b | baaaaaaa=a >
baaaaaaa -> a

# < a,b | baaaaaba=a >
baaaaaba -> a
baaaaaa -> aaaaaba

# < a,b | baaaabaa=a >
baaaabaa -> a
baaaaa -> aaabaa

# < a,b | baaaabba=a >
baaaabba -> a
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaa=a >
baaabaaa -> a
baaaa -> abaaa

# < a,b | baaabbba=a >
baaabbba -> a
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaa=a >
baabaaaa -> a

# < a,b | baabaaba=a >
baabaaba -> a
baaa -> aaba

# < a,b | baababaa=a >
baababaa -> a
baabaa -> ababaa
baaa -> abaa

# < a,b | baabbaaa=a >
baabbaaa -> a

# < a,b | baabbbba=a >
baabbbba -> a
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaa=a >
babaaaaa -> a

# < a,b | babaaaba=a >
babaaaba -> a
babaaaa -> abaaaba

# < a,b | babaabaa=a >
babaabaa -> a

# < a,b | babaabba=a >
babaabba -> a
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaa=a >
bababaaa -> a

# < a,b | babababa=a >
babababa -> a
baa -> aba

# < a,b | bababbaa=a >
bababbaa -> a

# < a,b | babbaaaa=a >
babbaaaa -> a

# < a,b | babbaaba=a >
babbaaba -> a
babbaaa -> abbaaba

# < a,b | babbabaa=a >
babbabaa -> a

# < a,b | babbabba=a >
babbabba -> a
baba -> abba
baa -> aba

# < a,b | babbbaaa=a >
babbbaaa -> a

# < a,b | babbbaba=a >
babbbaba -> a
babbbaa -> abbbaba

# < a,b | babbbbaa=a >
babbbbaa -> a

# < a,b | babbbbba=a >
babbbbba -> a
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaa=a >
bbaaaaaa -> a

# < a,b | bbaaaaba=a >
bbaaaaba -> a

# < a,b | bbaaabaa=a >
bbaaabaa -> a

# < a,b | bbaaabba=a >
bbaaabba -> a
bbaaaa -> aaabba

# < a,b | bbaabaaa=a >
bbaabaaa -> a

# < a,b | bbaababa=a >
bbaababa -> a

# < a,b | bbaabbaa=a >
bbaabbaa -> a
bbaaa -> abbaa

# < a,b | bbaabbba=a >
bbaabbba -> a
bbaaba -> aabbba

# < a,b | bbabaaaa=a >
bbabaaaa -> a

# < a,b | bbabaaba=a >
bbabaaba -> a

# < a,b | bbababaa=a >
bbababaa -> a

# < a,b | bbababba=a >
bbababba -> a
bbabaa -> ababba

# < a,b | bbabbaaa=a >
bbabbaaa -> a

# < a,b | bbabbaba=a >
bbabbaba -> a

# < a,b | bbabbbaa=a >
bbabbbaa -> a

# < a,b | bbabbbba=a >
bbabbbba -> a
bbabba -> abbbba
bbaa -> abba

# < a,b | bbbaaaaa=a >
bbbaaaaa -> a

# < a,b | bbbaaaba=a >
bbbaaaba -> a

# < a,b | bbbaabaa=a >
bbbaabaa -> a

# < a,b | bbbaabba=a >
bbbaabba -> a

# < a,b | bbbabaaa=a >
bbbabaaa -> a

# < a,b | bbbababa=a >
bbbababa -> a

# < a,b | bbbabbaa=a >
bbbabbaa -> a

# < a,b | bbbabbba=a >
bbbabbba -> a
bbbaa -> abbba

# < a,b | bbbbaaaa=a >
bbbbaaaa -> a

# < a,b | bbbbaaba=a >
bbbbaaba -> a

# < a,b | bbbbabaa=a >
bbbbabaa -> a

# < a,b | bbbbabba=a >
bbbbabba -> a

# < a,b | bbbbbaaa=a >
bbbbbaaa -> a

# < a,b | bbbbbaba=a >
bbbbbaba -> a

# < a,b | bbbbbbaa=a >
bbbbbbaa -> a

# < a,b | bbbbbbba=a >
bbbbbbba -> a

# < a,b | baaaaaaaa=a >
baaaaaaaa -> a

# < a,b | baaaaaaba=a >
baaaaaaba -> a
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaa=a >
baaaaabaa -> a
baaaaaa -> aaaabaa

# < a,b | baaaaabba=a >
baaaaabba -> a
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaa=a >
baaaabaaa -> a
baaaaa -> aabaaa

# < a,b | baaaabbba=a >
baaaabbba -> a
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaa=a >
baaabaaaa -> a

# < a,b | baaababaa=a >
baaababaa -> a
baaabaa -> aababaa
baaaa -> aabaa

# < a,b | baaabbbba=a >
baaabbbba -> a
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaa=a >
baabaaaaa -> a

# < a,b | baabaaaba=a >
baabaaaba -> a
baabaaaa -> aabaaaba

# < a,b | baabaabaa=a >
baabaabaa -> a
baaa -> abaa

# < a,b | baababaaa=a >
baababaaa -> a

# < a,b | baabbaaaa=a >
baabbaaaa -> a

# < a,b | baabbaaba=a >
baabbaaba -> a
baabbaaa -> aabbaaba

# < a,b | baabbbaaa=a >
baabbbaaa -> a

# < a,b | baabbbbba=a >
baabbbbba -> a
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaa=a >
babaaaaaa -> a

# < a,b | babaaaaba=a >
babaaaaba -> a
babaaaaa -> abaaaaba

# < a,b | babaaabaa=a >
babaaabaa -> a

# < a,b | babaaabba=a >
babaaabba -> a
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaa=a >
babaabaaa -> a

# < a,b | babaababa=a >
babaababa -> a
babaabaa -> abaababa
babaaa -> aababa

# < a,b | babaabbaa=a >
babaabbaa -> a

# < a,b | babaabbba=a >
babaabbba -> a
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaa=a >
bababaaaa -> a

# < a,b | bababaaba=a >
bababaaba -> a
bababaaa -> ababaaba

# < a,b | babababaa=a >
babababaa -> a

# < a,b | bababbaaa=a >
bababbaaa -> a

# < a,b | bababbaba=a >
bababbaba -> a
bababa -> abbaba
baa -> aba

# < a,b | bababbbaa=a >
bababbbaa -> a

# < a,b | babbaaaaa=a >
babbaaaaa -> a

# < a,b | babbaaaba=a >
babbaaaba -> a
babbaaaa -> abbaaaba

# < a,b | babbaabaa=a >
babbaabaa -> a

# < a,b | babbaabba=a >
babbaabba -> a
babbaaba -> abbaabba
babbaaa -> abbaaba

# < a,b | babbabaaa=a >
babbabaaa -> a

# < a,b | babbababa=a >
babbababa -> a
babbabaa -> abbababa

# < a,b | babbabbaa=a >
babbabbaa -> a

# < a,b | babbbaaaa=a >
babbbaaaa -> a

# < a,b | babbbaaba=a >
babbbaaba -> a
babbbaaa -> abbbaaba

# < a,b | babbbabaa=a >
babbbabaa -> a

# < a,b | babbbabba=a >
babbbabba -> a
babbbaba -> abbbabba
babbbaa -> abbbaba

# < a,b | babbbbaaa=a >
babbbbaaa -> a

# < a,b | babbbbaba=a >
babbbbaba -> a
babbbbaa -> abbbbaba

# < a,b | babbbbbaa=a >
babbbbbaa -> a

# < a,b | babbbbbba=a >
babbbbbba -> a
babbbbba -> abbbbbba
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaaa=a >
bbaaaaaaa -> a

# < a,b | bbaaaaaba=a >
bbaaaaaba -> a

# < a,b | bbaaaabaa=a >
bbaaaabaa -> a

# < a,b | bbaaaabba=a >
bbaaaabba -> a
bbaaaaa -> aaaabba

# < a,b | bbaaabaaa=a >
bbaaabaaa -> a

# < a,b | bbaaababa=a >
bbaaababa -> a

# < a,b | bbaaabbaa=a >
bbaaabbaa -> a
bbaaaa -> aabbaa

# < a,b | bbaaabbba=a >
bbaaabbba -> a
bbaaaba -> aaabbba

# < a,b | bbaabaaaa=a >
bbaabaaaa -> a

# < a,b | bbaabaaba=a >
bbaabaaba -> a

# < a,b | bbaababaa=a >
bbaababaa -> a

# < a,b | bbaababba=a >
bbaababba -> a
bbaabaa -> aababba

# < a,b | bbaabbaaa=a >
bbaabbaaa -> a

# < a,b | bbaabbaba=a >
bbaabbaba -> a

# < a,b | bbaabbbaa=a >
bbaabbbaa -> a
bbaaba -> abbbaa

# < a,b | bbaabbbba=a >
bbaabbbba -> a
bbaabba -> aabbbba
bbaaa -> aabba

# < a,b | bbabaaaaa=a >
bbabaaaaa -> a

# < a,b | bbabaaaba=a >
bbabaaaba -> a

# < a,b | bbabaabaa=a >
bbabaabaa -> a

# < a,b | bbabaabba=a >
bbabaabba -> a
bbabaaa -> abaabba

# < a,b | bbababaaa=a >
bbababaaa -> a

# < a,b | bbabababa=a >
bbabababa -> a

# < a,b | bbababbaa=a >
bbababbaa -> a

# < a,b | bbababbba=a >
bbababbba -> a
bbababa -> ababbba

# < a,b | bbabbaaaa=a >
bbabbaaaa -> a

# < a,b | bbabbaaba=a >
bbabbaaba -> a

# < a,b | bbabbabaa=a >
bbabbabaa -> a

# < a,b | bbabbabba=a >
bbabbabba -> a
bbaa -> abba

# < a,b | bbabbbaaa=a >
bbabbbaaa -> a

# < a,b | bbabbbaba=a >
bbabbbaba -> a

# < a,b | bbabbbbaa=a >
bbabbbbaa -> a

# < a,b | bbabbbbba=a >
bbabbbbba -> a
bbabbba -> abbbbba
bbaba -> abbba

# < a,b | bbbaaaaaa=a >
bbbaaaaaa -> a

# < a,b | bbbaaaaba=a >
bbbaaaaba -> a

# < a,b | bbbaaabaa=a >
bbbaaabaa -> a

# < a,b | bbbaaabba=a >
bbbaaabba -> a

# < a,b | bbbaabaaa=a >
bbbaabaaa -> a

# < a,b | bbbaababa=a >
bbbaababa -> a

# < a,b | bbbaabbaa=a >
bbbaabbaa -> a

# < a,b | bbbaabbba=a >
bbbaabbba -> a
bbbaaa -> aabbba

# < a,b | bbbabaaaa=a >
bbbabaaaa -> a

# < a,b | bbbabaaba=a >
bbbabaaba -> a

# < a,b | bbbababaa=a >
bbbababaa -> a

# < a,b | bbbababba=a >
bbbababba -> a

# < a,b | bbbabbaaa=a >
bbbabbaaa -> a

# < a,b | bbbabbaba=a >
bbbabbaba -> a

# < a,b | bbbabbbaa=a >
bbbabbbaa -> a

# < a,b | bbbabbbba=a >
bbbabbbba -> a
bbbaba -> abbbba

# < a,b | bbbbaaaaa=a >
bbbbaaaaa -> a

# < a,b | bbbbaaaba=a >
bbbbaaaba -> a

# < a,b | bbbbaabaa=a >
bbbbaabaa -> a

# < a,b | bbbbaabba=a >
bbbbaabba -> a

# < a,b | bbbbabaaa=a >
bbbbabaaa -> a

# < a,b | bbbbababa=a >
bbbbababa -> a

# < a,b | bbbbabbaa=a >
bbbbabbaa -> a

# < a,b | bbbbabbba=a >
bbbbabbba -> a

# < a,b | bbbbbaaaa=a >
bbbbbaaaa -> a

# < a,b | bbbbbaaba=a >
bbbbbaaba -> a

# < a,b | bbbbbabaa=a >
bbbbbabaa -> a

# < a,b | bbbbbabba=a >
bbbbbabba -> a

# < a,b | bbbbbbaaa=a >
bbbbbbaaa -> a

# < a,b | bbbbbbaba=a >
bbbbbbaba -> a

# < a,b | bbbbbbbaa=a >
bbbbbbbaa -> a

# < a,b | bbbbbbbba=a >
bbbbbbbba -> a

# < a,b | baaaaaaaaa=a >
baaaaaaaaa -> a

# < a,b | baaaaaaaba=a >
baaaaaaaba -> a
baaaaaaaa -> aaaaaaaba

# < a,b | baaaaaabaa=a >
baaaaaabaa -> a
baaaaaaa -> aaaaabaa

# < a,b | baaaaaabba=a >
baaaaaabba -> a
baaaaaaba -> aaaaaabba
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaaa=a >
baaaaabaaa -> a
baaaaaa -> aaabaaa

# < a,b | baaaaabbba=a >
baaaaabbba -> a
baaaaabba -> aaaaabbba
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaaa=a >
baaaabaaaa -> a
baaaaa -> abaaaa

# < a,b | baaaababaa=a >
baaaababaa -> a
baaaabaa -> aaababaa
baaaaa -> aaabaa

# < a,b | baaaabbbba=a >
baaaabbbba -> a
baaaabbba -> aaaabbbba
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaaa=a >
baaabaaaaa -> a

# < a,b | baaabaaaba=a >
baaabaaaba -> a
baaaa -> aaaba

# < a,b | baaabbaaaa=a >
baaabbaaaa -> a

# < a,b | baaabbbbba=a >
baaabbbbba -> a
baaabbbba -> aaabbbbba
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaaa=a >
baabaaaaaa -> a

# < a,b | baabaaaaba=a >
baabaaaaba -> a
baabaaaaa -> aabaaaaba

# < a,b | baabaaabaa=a >
baabaaabaa -> a
baabaaaa -> abaaabaa

# < a,b | baabaaabba=a >
baabaaabba -> a
baabaaaba -> aabaaabba
baabaaaa -> aabaaaba

# < a,b | baabaabaaa=a >
baabaabaaa -> a

# < a,b | baababaaaa=a >
baababaaaa -> a

# < a,b | baabababaa=a >
baabababaa -> a
baababaa -> abababaa
baabaa -> ababaa
baaa -> abaa

# < a,b | baababbaaa=a >
baababbaaa -> a

# < a,b | baabbaaaaa=a >
baabbaaaaa -> a

# < a,b | baabbaaaba=a >
baabbaaaba -> a
baabbaaaa -> aabbaaaba

# < a,b | baabbaabaa=a >
baabbaabaa -> a
baabbaaa -> abbaabaa

# < a,b | baabbaabba=a >
baabbaabba -> a
baaba -> aabba
baaa -> aaba

# < a,b | baabbabaaa=a >
baabbabaaa -> a

# < a,b | baabbbaaaa=a >
baabbbaaaa -> a

# < a,b | baabbbaaba=a >
baabbbaaba -> a
baabbbaaa -> aabbbaaba

# < a,b | baabbbbaaa=a >
baabbbbaaa -> a

# < a,b | baabbbbbba=a >
baabbbbbba -> a
baabbbbba -> aabbbbbba
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaaa=a >
babaaaaaaa -> a

# < a,b | babaaaaaba=a >
babaaaaaba -> a
babaaaaaa -> abaaaaaba

# < a,b | babaaaabaa=a >
babaaaabaa -> a

# < a,b | babaaaabba=a >
babaaaabba -> a
babaaaaba -> abaaaabba
babaaaaa -> abaaaaba

# < a,b | babaaabaaa=a >
babaaabaaa -> a

# < a,b | babaaababa=a >
babaaababa -> a
babaaabaa -> abaaababa
babaaaa -> aaababa

# < a,b | babaaabbaa=a >
babaaabbaa -> a

# < a,b | babaaabbba=a >
babaaabbba -> a
babaaabba -> abaaabbba
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaaa=a >
babaabaaaa -> a

# < a,b | babaabaaba=a >
babaabaaba -> a
babaabaaa -> abaabaaba

# < a,b | babaababaa=a >
babaababaa -> a
babaaa -> ababaa

# < a,b | babaabbaaa=a >
babaabbaaa -> a

# < a,b | babaabbaba=a >
babaabbaba -> a
babaabbaa -> abaabbaba
babaaba -> aabbaba
babaaa -> aabbaa

# < a,b | babaabbbaa=a >
babaabbbaa -> a

# < a,b | babaabbbba=a >
babaabbbba -> a
babaabbba -> abaabbbba
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaaa=a >
bababaaaaa -> a

# < a,b | bababaaaba=a >
bababaaaba -> a
bababaaaa -> ababaaaba

# < a,b | bababaabaa=a >
bababaabaa -> a

# < a,b | bababaabba=a >
bababaabba -> a
bababaaba -> ababaabba
bababaaa -> ababaaba

# < a,b | babababaaa=a >
babababaaa -> a

# < a,b | bababababa=a >
bababababa -> a
baa -> aba

# < a,b | babababbaa=a >
babababbaa -> a

# < a,b | bababbaaaa=a >
bababbaaaa -> a

# < a,b | bababbaaba=a >
bababbaaba -> a
bababbaaa -> ababbaaba

# < a,b | bababbabaa=a >
bababbabaa -> a

# < a,b | bababbbaaa=a >
bababbbaaa -> a

# < a,b | bababbbbaa=a >
bababbbbaa -> a

# < a,b | babbaaaaaa=a >
babbaaaaaa -> a

# < a,b | babbaaaaba=a >
babbaaaaba -> a
babbaaaaa -> abbaaaaba

# < a,b | babbaaabaa=a >
babbaaabaa -> a

# < a,b | babbaaabba=a >
babbaaabba -> a
babbaaaba -> abbaaabba
babbaaaa -> abbaaaba

# < a,b | babbaabaaa=a >
babbaabaaa -> a

# < a,b | babbaababa=a >
babbaababa -> a
babbaabaa -> abbaababa

# < a,b | babbaabbaa=a >
babbaabbaa -> a

# < a,b | babbaabbba=a >
babbaabbba -> a
babbaabba -> abbaabbba
babbaaba -> abbaabba
babbaaa -> abbaaba

# < a,b | babbabaaaa=a >
babbabaaaa -> a

# < a,b | babbabaaba=a >
babbabaaba -> a
babbabaaa -> abbabaaba

# < a,b | babbababaa=a >
babbababaa -> a

# < a,b | babbababba=a >
babbababba -> a
babbababa -> abbababba
babbaa -> ababba
babbabaa -> abbababa

# < a,b | babbabbaaa=a >
babbabbaaa -> a

# < a,b | babbabbaba=a >
babbabbaba -> a
babbabbaa -> abbabbaba

# < a,b | babbabbbaa=a >
babbabbbaa -> a

# < a,b | babbbaaaaa=a >
babbbaaaaa -> a

# < a,b | babbbaaaba=a >
babbbaaaba -> a
babbbaaaa -> abbbaaaba

# < a,b | babbbaabaa=a >
babbbaabaa -> a

# < a,b | babbbaabba=a >
babbbaabba -> a
babbbaaba -> abbbaabba
babbbaaa -> abbbaaba

# < a,b | babbbabaaa=a >
babbbabaaa -> a

# < a,b | babbbababa=a >
babbbababa -> a
babbbabaa -> abbbababa

# < a,b | babbbabbaa=a >
babbbabbaa -> a

# < a,b | babbbabbba=a >
babbbabbba -> a
babba -> abbba
baba -> abba
baa -> aba

# < a,b | babbbbaaaa=a >
babbbbaaaa -> a

# < a,b | babbbbaaba=a >
babbbbaaba -> a
babbbbaaa -> abbbbaaba

# < a,b | babbbbabaa=a >
babbbbabaa -> a

# < a,b | babbbbabba=a >
babbbbabba -> a
babbbbaba -> abbbbabba
babbbbaa -> abbbbaba

# < a,b | babbbbbaaa=a >
babbbbbaaa -> a

# < a,b | babbbbbaba=a >
babbbbbaba -> a
babbbbbaa -> abbbbbaba

# < a,b | babbbbbbaa=a >
babbbbbbaa -> a

# < a,b | babbbbbbba=a >
babbbbbbba -> a
babbbbbba -> abbbbbbba
babbbbba -> abbbbbba
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaaaa=a >
bbaaaaaaaa -> a

# < a,b | bbaaaaaaba=a >
bbaaaaaaba -> a

# < a,b | bbaaaaabaa=a >
bbaaaaabaa -> a

# < a,b | bbaaaaabba=a >
bbaaaaabba -> a
bbaaaaaa -> aaaaabba

# < a,b | bbaaaabaaa=a >
bbaaaabaaa -> a

# < a,b | bbaaaababa=a >
bbaaaababa -> a

# < a,b | bbaaaabbaa=a >
bbaaaabbaa -> a
bbaaaaa -> aaabbaa

# < a,b | bbaaaabbba=a >
bbaaaabbba -> a
bbaaaaba -> aaaabbba

# < a,b | bbaaabaaaa=a >
bbaaabaaaa -> a

# < a,b | bbaaabaaba=a >
bbaaabaaba -> a

# < a,b | bbaaababaa=a >
bbaaababaa -> a

# < a,b | bbaaababba=a >
bbaaababba -> a
bbaaabaa -> aaababba

# < a,b | bbaaabbaaa=a >
bbaaabbaaa -> a
bbaaaa -> abbaaa

# < a,b | bbaaabbaba=a >
bbaaabbaba -> a

# < a,b | bbaaabbbaa=a >
bbaaabbbaa -> a
bbaaaba -> aabbbaa

# < a,b | bbaaabbbba=a >
bbaaabbbba -> a
bbaaabba -> aaabbbba
bbaaaa -> aaabba

# < a,b | bbaabaaaaa=a >
bbaabaaaaa -> a

# < a,b | bbaabaaaba=a >
bbaabaaaba -> a

# < a,b | bbaabaabaa=a >
bbaabaabaa -> a

# < a,b | bbaabaabba=a >
bbaabaabba -> a
bbaabaaa -> aabaabba

# < a,b | bbaababaaa=a >
bbaababaaa -> a

# < a,b | bbaabababa=a >
bbaabababa -> a

# < a,b | bbaababbaa=a >
bbaababbaa -> a
bbaabaa -> ababbaa

# < a,b | bbaababbba=a >
bbaababbba -> a
bbaababa -> aababbba

# < a,b | bbaabbaaaa=a >
bbaabbaaaa -> a

# < a,b | bbaabbaaba=a >
bbaabbaaba -> a

# < a,b | bbaabbabaa=a >
bbaabbabaa -> a

# < a,b | bbaabbbaaa=a >
bbaabbbaaa -> a

# < a,b | bbaabbbaba=a >
bbaabbbaba -> a

# < a,b | bbaabbbbba=a >
bbaabbbbba -> a
bbaabbba -> aabbbbba
bbaaba -> aabbba

# < a,b | bbabaaaaaa=a >
bbabaaaaaa -> a

# < a,b | bbabaaaaba=a >
bbabaaaaba -> a

# < a,b | bbabaaabaa=a >
bbabaaabaa -> a

# < a,b | bbabaaabba=a >
bbabaaabba -> a
bbabaaaa -> abaaabba

# < a,b | bbabaabaaa=a >
bbabaabaaa -> a

# < a,b | bbabaababa=a >
bbabaababa -> a

# < a,b | bbabaabbaa=a >
bbabaabbaa -> a

# < a,b | bbabaabbba=a >
bbabaabbba -> a
bbabaaba -> abaabbba

# < a,b | bbababaaaa=a >
bbababaaaa -> a

# < a,b | bbababaaba=a >
bbababaaba -> a

# < a,b | bbabababaa=a >
bbabababaa -> a

# < a,b | bbabababba=a >
bbabababba -> a
bbababaa -> abababba

# < a,b | bbababbaaa=a >
bbababbaaa -> a

# < a,b | bbababbaba=a >
bbababbaba -> a
bbabaa -> abbaba

# < a,b | bbababbbaa=a >
bbababbbaa -> a

# < a,b | bbababbbba=a >
bbababbbba -> a
bbababba -> ababbbba
bbabaa -> ababba

# < a,b | bbabbaaaaa=a >
bbabbaaaaa -> a

# < a,b | bbabbaaaba=a >
bbabbaaaba -> a

# < a,b | bbabbaabaa=a >
bbabbaabaa -> a

# < a,b | bbabbaabba=a >
bbabbaabba -> a
bbabbaaa -> abbaabba

# < a,b | bbabbabaaa=a >
bbabbabaaa -> a

# < a,b | bbabbababa=a >
bbabbababa -> a

# < a,b | bbabbabbaa=a >
bbabbabbaa -> a

# < a,b | bbabbabbba=a >
bbabbabbba -> a
bbabbaba -> abbabbba

# < a,b | bbabbbaaaa=a >
bbabbbaaaa -> a

# < a,b | bbabbbaaba=a >
bbabbbaaba -> a

# < a,b | bbabbbabaa=a >
bbabbbabaa -> a

# < a,b | bbabbbabba=a >
bbabbbabba -> a
bbabbbaa -> abbbabba

# < a,b | bbabbbbaaa=a >
bbabbbbaaa -> a

# < a,b | bbabbbbaba=a >
bbabbbbaba -> a

# < a,b | bbabbbbbaa=a >
bbabbbbbaa -> a

# < a,b | bbabbbbbba=a >
bbabbbbbba -> a
bbabbbba -> abbbbbba
bbabba -> abbbba
bbaa -> abba

# < a,b | bbbaaaaaaa=a >
bbbaaaaaaa -> a

# < a,b | bbbaaaaaba=a >
bbbaaaaaba -> a

# < a,b | bbbaaaabaa=a >
bbbaaaabaa -> a

# < a,b | bbbaaaabba=a >
bbbaaaabba -> a

# < a,b | bbbaaabaaa=a >
bbbaaabaaa -> a

# < a,b | bbbaaababa=a >
bbbaaababa -> a

# < a,b | bbbaaabbaa=a >
bbbaaabbaa -> a

# < a,b | bbbaaabbba=a >
bbbaaabbba -> a
bbbaaaa -> aaabbba

# < a,b | bbbaabaaaa=a >
bbbaabaaaa -> a

# < a,b | bbbaabaaba=a >
bbbaabaaba -> a

# < a,b | bbbaababaa=a >
bbbaababaa -> a

# < a,b | bbbaababba=a >
bbbaababba -> a

# < a,b | bbbaabbaaa=a >
bbbaabbaaa -> a

# < a,b | bbbaabbaba=a >
bbbaabbaba -> a

# < a,b | bbbaabbbaa=a >
bbbaabbbaa -> a
bbbaaa -> abbbaa

# < a,b | bbbaabbbba=a >
bbbaabbbba -> a
bbbaaba -> aabbbba

# < a,b | bbbabaaaaa=a >
bbbabaaaaa -> a

# < a,b | bbbabaaaba=a >
bbbabaaaba -> a

# < a,b | bbbabaabaa=a >
bbbabaabaa -> a

# < a,b | bbbabaabba=a >
bbbabaabba -> a

# < a,b | bbbababaaa=a >
bbbababaaa -> a

# < a,b | bbbabababa=a >
bbbabababa -> a

# < a,b | bbbababbaa=a >
bbbababbaa -> a

# < a,b | bbbababbba=a >
bbbababbba -> a
bbbabaa -> ababbba

# < a,b | bbbabbaaaa=a >
bbbabbaaaa -> a

# < a,b | bbbabbaaba=a >
bbbabbaaba -> a

# < a,b | bbbabbabaa=a >
bbbabbabaa -> a

# < a,b | bbbabbabba=a >
bbbabbabba -> a

# < a,b | bbbabbbaaa=a >
bbbabbbaaa -> a

# < a,b | bbbabbbaba=a >
bbbabbbaba -> a

# < a,b | bbbabbbbaa=a >
bbbabbbbaa -> a

# < a,b | bbbabbbbba=a >
bbbabbbbba -> a
bbbabba -> abbbbba

# < a,b | bbbbaaaaaa=a >
bbbbaaaaaa -> a

# < a,b | bbbbaaaaba=a >
bbbbaaaaba -> a

# < a,b | bbbbaaabaa=a >
bbbbaaabaa -> a

# < a,b | bbbbaaabba=a >
bbbbaaabba -> a

# < a,b | bbbbaabaaa=a >
bbbbaabaaa -> a

# < a,b | bbbbaababa=a >
bbbbaababa -> a

# < a,b | bbbbaabbaa=a >
bbbbaabbaa -> a

# < a,b | bbbbaabbba=a >
bbbbaabbba -> a

# < a,b | bbbbabaaaa=a >
bbbbabaaaa -> a

# < a,b | bbbbabaaba=a >
bbbbabaaba -> a

# < a,b | bbbbababaa=a >
bbbbababaa -> a

# < a,b | bbbbababba=a >
bbbbababba -> a

# < a,b | bbbbabbaaa=a >
bbbbabbaaa -> a

# < a,b | bbbbabbaba=a >
bbbbabbaba -> a

# < a,b | bbbbabbbaa=a >
bbbbabbbaa -> a

# < a,b | bbbbabbbba=a >
bbbbabbbba -> a
bbbbaa -> abbbba

# < a,b | bbbbbaaaaa=a >
bbbbbaaaaa -> a

# < a,b | bbbbbaaaba=a >
bbbbbaaaba -> a

# < a,b | bbbbbaabaa=a >
bbbbbaabaa -> a

# < a,b | bbbbbaabba=a >
bbbbbaabba -> a

# < a,b | bbbbbabaaa=a >
bbbbbabaaa -> a

# < a,b | bbbbbababa=a >
bbbbbababa -> a

# < a,b | bbbbbabbaa=a >
bbbbbabbaa -> a

# < a,b | bbbbbabbba=a >
bbbbbabbba -> a

# < a,b | bbbbbbaaaa=a >
bbbbbbaaaa -> a

# < a,b | bbbbbbaaba=a >
bbbbbbaaba -> a

# < a,b | bbbbbbabaa=a >
bbbbbbabaa -> a

# < a,b | bbbbbbabba=a >
bbbbbbabba -> a

# < a,b | bbbbbbbaaa=a >
bbbbbbbaaa -> a

# < a,b | bbbbbbbaba=a >
bbbbbbbaba -> a

# < a,b | bbbbbbbbaa=a >
bbbbbbbbaa -> a

# < a,b | bbbbbbbbba=a >
bbbbbbbbba -> a

# < a,b | baaaaaaaaaa=a >
baaaaaaaaaa -> a

# < a,b | baaaaaaaaba=a >
baaaaaaaaba -> a
baaaaaaaaa -> aaaaaaaaba

# < a,b | baaaaaaabaa=a >
baaaaaaabaa -> a
baaaaaaaa -> aaaaaabaa

# < a,b | baaaaaaabba=a >
baaaaaaabba -> a
baaaaaaaba -> aaaaaaabba
baaaaaaaa -> aaaaaaaba

# < a,b | baaaaaabaaa=a >
baaaaaabaaa -> a
baaaaaaa -> aaaabaaa

# < a,b | baaaaaabbba=a >
baaaaaabbba -> a
baaaaaabba -> aaaaaabbba
baaaaaaba -> aaaaaabba
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaaaa=a >
baaaaabaaaa -> a
baaaaaa -> aabaaaa

# < a,b | baaaaababaa=a >
baaaaababaa -> a
baaaaabaa -> aaaababaa
baaaaaa -> aaaabaa

# < a,b | baaaaabbbba=a >
baaaaabbbba -> a
baaaaabbba -> aaaaabbbba
baaaaabba -> aaaaabbba
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaaaa=a >
baaaabaaaaa -> a

# < a,b | baaaabbbbba=a >
baaaabbbbba -> a
baaaabbbba -> aaaabbbbba
baaaabbba -> aaaabbbba
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaaaa=a >
baaabaaaaaa -> a

# < a,b | baaabaaaaba=a >
baaabaaaaba -> a
baaabaaaaa -> aaabaaaaba

# < a,b | baaabaaabaa=a >
baaabaaabaa -> a
baaaa -> aabaa

# < a,b | baaabaabaaa=a >
baaabaabaaa -> a
baaabaaa -> abaabaaa
baaaa -> abaaa

# < a,b | baaababaaaa=a >
baaababaaaa -> a

# < a,b | baaabababaa=a >
baaabababaa -> a
baaababaa -> aabababaa
baaabaa -> aababaa
baaaa -> aabaa

# < a,b | baaabbaaaaa=a >
baaabbaaaaa -> a

# < a,b | baaabbaaaba=a >
baaabbaaaba -> a
baaabbaaaa -> aaabbaaaba

# < a,b | baaabbbaaaa=a >
baaabbbaaaa -> a

# < a,b | baaabbbbbba=a >
baaabbbbbba -> a
baaabbbbba -> aaabbbbbba
baaabbbba -> aaabbbbba
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaaaa=a >
baabaaaaaaa -> a

# < a,b | baabaaaaaba=a >
baabaaaaaba -> a
baabaaaaaa -> aabaaaaaba

# < a,b | baabaaaabaa=a >
baabaaaabaa -> a
baabaaaaa -> abaaaabaa

# < a,b | baabaaaabba=a >
baabaaaabba -> a
baabaaaaba -> aabaaaabba
baabaaaaa -> aabaaaaba

# < a,b | baabaaabaaa=a >
baabaaabaaa -> a

# < a,b | baabaaabbba=a >
baabaaabbba -> a
baabaaabba -> aabaaabbba
baabaaaba -> aabaaabba
baabaaaa -> aabaaaba

# < a,b | baabaabaaaa=a >
baabaabaaaa -> a

# < a,b | baabaabaaba=a >
baabaabaaba -> a
baaa -> aaba

# < a,b | baabaabbaaa=a >
baabaabbaaa -> a

# < a,b | baababaaaaa=a >
baababaaaaa -> a

# < a,b | baababaaaba=a >
baababaaaba -> a
baababaaaa -> aababaaaba

# < a,b | baababaabaa=a >
baababaabaa -> a
baababaaa -> ababaabaa

# < a,b | baabababaaa=a >
baabababaaa -> a

# < a,b | baababbaaaa=a >
baababbaaaa -> a

# < a,b | baababbbaaa=a >
baababbbaaa -> a

# < a,b | baabbaaaaaa=a >
baabbaaaaaa -> a

# < a,b | baabbaaaaba=a >
baabbaaaaba -> a
baabbaaaaa -> aabbaaaaba

# < a,b | baabbaaabaa=a >
baabbaaabaa -> a
baabbaaaa -> abbaaabaa

# < a,b | baabbaaabba=a >
baabbaaabba -> a
baabbaaaba -> aabbaaabba
baabbaaaa -> aabbaaaba

# < a,b | baabbaabaaa=a >
baabbaabaaa -> a

# < a,b | baabbabaaaa=a >
baabbabaaaa -> a

# < a,b | baabbabaaba=a >
baabbabaaba -> a
baabbabaaa -> aabbabaaba

# < a,b | baabbabbaaa=a >
baabbabbaaa -> a

# < a,b | baabbbaaaaa=a >
baabbbaaaaa -> a

# < a,b | baabbbaaaba=a >
baabbbaaaba -> a
baabbbaaaa -> aabbbaaaba

# < a,b | baabbbaabaa=a >
baabbbaabaa -> a
baabbbaaa -> abbbaabaa

# < a,b | baabbbaabba=a >
baabbbaabba -> a
baabbbaaba -> aabbbaabba
baabbbaaa -> aabbbaaba

# < a,b | baabbbabaaa=a >
baabbbabaaa -> a

# < a,b | baabbbbaaaa=a >
baabbbbaaaa -> a

# < a,b | baabbbbaaba=a >
baabbbbaaba -> a
baabbbbaaa -> aabbbbaaba

# < a,b | baabbbbbaaa=a >
baabbbbbaaa -> a

# < a,b | baabbbbbbba=a >
baabbbbbbba -> a
baabbbbbba -> aabbbbbbba
baabbbbba -> aabbbbbba
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaaaa=a >
babaaaaaaaa -> a

# < a,b | babaaaaaaba=a >
babaaaaaaba -> a
babaaaaaaa -> abaaaaaaba

# < a,b | babaaaaabaa=a >
babaaaaabaa -> a

# < a,b | babaaaaabba=a >
babaaaaabba -> a
babaaaaaba -> abaaaaabba
babaaaaaa -> abaaaaaba

# < a,b | babaaaabaaa=a >
babaaaabaaa -> a

# < a,b | babaaaababa=a >
babaaaababa -> a
babaaaabaa -> abaaaababa
babaaaaa -> aaaababa

# < a,b | babaaaabbaa=a >
babaaaabbaa -> a

# < a,b | babaaaabbba=a >
babaaaabbba -> a
babaaaabba -> abaaaabbba
babaaaaba -> abaaaabba
babaaaaa -> abaaaaba

# < a,b | babaaabaaaa=a >
babaaabaaaa -> a

# < a,b | babaaabaaba=a >
babaaabaaba -> a
babaaabaaa -> abaaabaaba

# < a,b | babaaababaa=a >
babaaababaa -> a
babaaaa -> aababaa

# < a,b | babaaabbaaa=a >
babaaabbaaa -> a

# < a,b | babaaabbaba=a >
babaaabbaba -> a
babaaabbaa -> abaaabbaba
babaaaba -> aaabbaba
babaaaa -> aaabbaa

# < a,b | babaaabbbaa=a >
babaaabbbaa -> a

# < a,b | babaaabbbba=a >
babaaabbbba -> a
babaaabbba -> abaaabbbba
babaaabba -> abaaabbba
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaaaa=a >
babaabaaaaa -> a

# < a,b | babaabaaaba=a >
babaabaaaba -> a
babaabaaaa -> abaabaaaba

# < a,b | babaabaabaa=a >
babaabaabaa -> a

# < a,b | babaabaabba=a >
babaabaabba -> a
babaabaaba -> abaabaabba
babaabaaa -> abaabaaba

# < a,b | babaababaaa=a >
babaababaaa -> a

# < a,b | babaababbaa=a >
babaababbaa -> a

# < a,b | babaabbaaaa=a >
babaabbaaaa -> a

# < a,b | babaabbaaba=a >
babaabbaaba -> a
babaabbaaa -> abaabbaaba

# < a,b | babaabbbaaa=a >
babaabbbaaa -> a

# < a,b | babaabbbbaa=a >
babaabbbbaa -> a

# < a,b | babaabbbbba=a >
babaabbbbba -> a
babaabbbba -> abaabbbbba
babaabbba -> abaabbbba
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaaaa=a >
bababaaaaaa -> a

# < a,b | bababaaaaba=a >
bababaaaaba -> a
bababaaaaa -> ababaaaaba

# < a,b | bababaaabaa=a >
bababaaabaa -> a

# < a,b | bababaaabba=a >
bababaaabba -> a
bababaaaba -> ababaaabba
bababaaaa -> ababaaaba

# < a,b | bababaabaaa=a >
bababaabaaa -> a

# < a,b | bababaababa=a >
bababaababa -> a
bababaabaa -> ababaababa
bababaaa -> abaababa

# < a,b | bababaabbaa=a >
bababaabbaa -> a

# < a,b | bababaabbba=a >
bababaabbba -> a
bababaabba -> ababaabbba
bababaaba -> ababaabba
bababaaa -> ababaaba

# < a,b | babababaaaa=a >
babababaaaa -> a

# < a,b | babababaaba=a >
babababaaba -> a
babababaaa -> abababaaba

# < a,b | bababababaa=a >
bababababaa -> a

# < a,b | babababbaaa=a >
babababbaaa -> a

# < a,b | babababbbaa=a >
babababbbaa -> a

# < a,b | bababbaaaaa=a >
bababbaaaaa -> a

# < a,b | bababbaaaba=a >
bababbaaaba -> a
bababbaaaa -> ababbaaaba

# < a,b | bababbaabaa=a >
bababbaabaa -> a

# < a,b | bababbaabba=a >
bababbaabba -> a
bababbaaba -> ababbaabba
bababbaaa -> ababbaaba

# < a,b | bababbabaaa=a >
bababbabaaa -> a

# < a,b | bababbababa=a >
bababbababa -> a
bababbabaa -> ababbababa
bababbaa -> abbababa

# < a,b | bababbabbaa=a >
bababbabbaa -> a

# < a,b | bababbbaaaa=a >
bababbbaaaa -> a

# < a,b | bababbbaaba=a >
bababbbaaba -> a
bababbbaaa -> ababbbaaba

# < a,b | bababbbabaa=a >
bababbbabaa -> a

# < a,b | bababbbbaaa=a >
bababbbbaaa -> a

# < a,b | bababbbbbaa=a >
bababbbbbaa -> a

# < a,b | babbaaaaaaa=a >
babbaaaaaaa -> a

# < a,b | babbaaaaaba=a >
babbaaaaaba -> a
babbaaaaaa -> abbaaaaaba

# < a,b | babbaaaabaa=a >
babbaaaabaa -> a

# < a,b | babbaaaabba=a >
babbaaaabba -> a
babbaaaaba -> abbaaaabba
babbaaaaa -> abbaaaaba

# < a,b | babbaaabaaa=a >
babbaaabaaa -> a

# < a,b | babbaaababa=a >
babbaaababa -> a
babbaaabaa -> abbaaababa

# < a,b | babbaaabbaa=a >
babbaaabbaa -> a

# < a,b | babbaaabbba=a >
babbaaabbba -> a
babbaaabba -> abbaaabbba
babbaaaba -> abbaaabba
babbaaaa -> abbaaaba

# < a,b | babbaabaaaa=a >
babbaabaaaa -> a

# < a,b | babbaabaaba=a >
babbaabaaba -> a
babbaabaaa -> abbaabaaba

# < a,b | babbaababaa=a >
babbaababaa -> a

# < a,b | babbaababba=a >
babbaababba -> a
babbaababa -> abbaababba
babbaaa -> aababba
babbaabaa -> abbaababa

# < a,b | babbaabbaaa=a >
babbaabbaaa -> a

# < a,b | babbaabbaba=a >
babbaabbaba -> a
babbaabbaa -> abbaabbaba

# < a,b | babbaabbbaa=a >
babbaabbbaa -> a

# < a,b | babbaabbbba=a >
babbaabbbba -> a
babbaabbba -> abbaabbbba
babbaabba -> abbaabbba
babbaaba -> abbaabba
babbaaa -> abbaaba

# < a,b | babbabaaaaa=a >
babbabaaaaa -> a

# < a,b | babbabaaaba=a >
babbabaaaba -> a
babbabaaaa -> abbabaaaba

# < a,b | babbabaabaa=a >
babbabaabaa -> a

# < a,b | babbabaabba=a >
babbabaabba -> a
babbabaaba -> abbabaabba
babbabaaa -> abbabaaba

# < a,b | babbababaaa=a >
babbababaaa -> a

# < a,b | babbabababa=a >
babbabababa -> a
babbababaa -> abbabababa

# < a,b | babbababbaa=a >
babbababbaa -> a

# < a,b | babbabbaaaa=a >
babbabbaaaa -> a

# < a,b | babbabbaaba=a >
babbabbaaba -> a
babbabbaaa -> abbabbaaba

# < a,b | babbabbabaa=a >
babbabbabaa -> a

# < a,b | babbabbabba=a >
babbabbabba -> a
baba -> abba
baa -> aba

# < a,b | babbabbbaaa=a >
babbabbbaaa -> a

# < a,b | babbabbbaba=a >
babbabbbaba -> a
babbabbbaa -> abbabbbaba

# < a,b | babbabbbbaa=a >
babbabbbbaa -> a

# < a,b | babbbaaaaaa=a >
babbbaaaaaa -> a

# < a,b | babbbaaaaba=a >
babbbaaaaba -> a
babbbaaaaa -> abbbaaaaba

# < a,b | babbbaaabaa=a >
babbbaaabaa -> a

# < a,b | babbbaaabba=a >
babbbaaabba -> a
babbbaaaba -> abbbaaabba
babbbaaaa -> abbbaaaba

# < a,b | babbbaabaaa=a >
babbbaabaaa -> a

# < a,b | babbbaababa=a >
babbbaababa -> a
babbbaabaa -> abbbaababa

# < a,b | babbbaabbaa=a >
babbbaabbaa -> a

# < a,b | babbbaabbba=a >
babbbaabbba -> a
babbbaabba -> abbbaabbba
babbbaaba -> abbbaabba
babbbaaa -> abbbaaba

# < a,b | babbbabaaaa=a >
babbbabaaaa -> a

# < a,b | babbbabaaba=a >
babbbabaaba -> a
babbbabaaa -> abbbabaaba

# < a,b | babbbababaa=a >
babbbababaa -> a

# < a,b | babbbababba=a >
babbbababba -> a
babbbababa -> abbbababba
babbbabaa -> abbbababa

# < a,b | babbbabbaaa=a >
babbbabbaaa -> a

# < a,b | babbbabbaba=a >
babbbabbaba -> a
babbbabbaa -> abbbabbaba

# < a,b | babbbabbbaa=a >
babbbabbbaa -> a

# < a,b | babbbbaaaaa=a >
babbbbaaaaa -> a

# < a,b | babbbbaaaba=a >
babbbbaaaba -> a
babbbbaaaa -> abbbbaaaba

# < a,b | babbbbaabaa=a >
babbbbaabaa -> a

# < a,b | babbbbaabba=a >
babbbbaabba -> a
babbbbaaba -> abbbbaabba
babbbbaaa -> abbbbaaba

# < a,b | babbbbabaaa=a >
babbbbabaaa -> a

# < a,b | babbbbababa=a >
babbbbababa -> a
babbbbabaa -> abbbbababa

# < a,b | babbbbabbaa=a >
babbbbabbaa -> a

# < a,b | babbbbabbba=a >
babbbbabbba -> a
babbbbabba -> abbbbabbba
babbbbaba -> abbbbabba
babbbbaa -> abbbbaba

# < a,b | babbbbbaaaa=a >
babbbbbaaaa -> a

# < a,b | babbbbbaaba=a >
babbbbbaaba -> a
babbbbbaaa -> abbbbbaaba

# < a,b | babbbbbabaa=a >
babbbbbabaa -> a

# < a,b | babbbbbabba=a >
babbbbbabba -> a
babbbbbaba -> abbbbbabba
babbbbbaa -> abbbbbaba

# < a,b | babbbbbbaaa=a >
babbbbbbaaa -> a

# < a,b | babbbbbbaba=a >
babbbbbbaba -> a
babbbbbbaa -> abbbbbbaba

# < a,b | babbbbbbbaa=a >
babbbbbbbaa -> a

# < a,b | babbbbbbbba=a >
babbbbbbbba -> a
babbbbbbba -> abbbbbbbba
babbbbbba -> abbbbbbba
babbbbba -> abbbbbba
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaaaaa=a >
bbaaaaaaaaa -> a

# < a,b | bbaaaaaaaba=a >
bbaaaaaaaba -> a

# < a,b | bbaaaaaabaa=a >
bbaaaaaabaa -> a

# < a,b | bbaaaaaabba=a >
bbaaaaaabba -> a
bbaaaaaaa -> aaaaaabba

# < a,b | bbaaaaabaaa=a >
bbaaaaabaaa -> a

# < a,b | bbaaaaababa=a >
bbaaaaababa -> a

# < a,b | bbaaaaabbaa=a >
bbaaaaabbaa -> a
bbaaaaaa -> aaaabbaa

# < a,b | bbaaaaabbba=a >
bbaaaaabbba -> a
bbaaaaaba -> aaaaabbba

# < a,b | bbaaaabaaaa=a >
bbaaaabaaaa -> a

# < a,b | bbaaaabaaba=a >
bbaaaabaaba -> a

# < a,b | bbaaaababaa=a >
bbaaaababaa -> a

# < a,b | bbaaaababba=a >
bbaaaababba -> a
bbaaaabaa -> aaaababba

# < a,b | bbaaaabbaaa=a >
bbaaaabbaaa -> a
bbaaaaa -> aabbaaa

# < a,b | bbaaaabbaba=a >
bbaaaabbaba -> a

# < a,b | bbaaaabbbaa=a >
bbaaaabbbaa -> a
bbaaaaba -> aaabbbaa

# < a,b | bbaaaabbbba=a >
bbaaaabbbba -> a
bbaaaabba -> aaaabbbba
bbaaaaa -> aaaabba

# < a,b | bbaaabaaaaa=a >
bbaaabaaaaa -> a

# < a,b | bbaaabaaaba=a >
bbaaabaaaba -> a

# < a,b | bbaaabaabaa=a >
bbaaabaabaa -> a

# < a,b | bbaaabaabba=a >
bbaaabaabba -> a
bbaaabaaa -> aaabaabba

# < a,b | bbaaababaaa=a >
bbaaababaaa -> a

# < a,b | bbaaabababa=a >
bbaaabababa -> a

# < a,b | bbaaababbaa=a >
bbaaababbaa -> a
bbaaabaa -> aababbaa

# < a,b | bbaaababbba=a >
bbaaababbba -> a
bbaaababa -> aaababbba

# < a,b | bbaaabbaaaa=a >
bbaaabbaaaa -> a

# < a,b | bbaaabbaaba=a >
bbaaabbaaba -> a

# < a,b | bbaaabbabaa=a >
bbaaabbabaa -> a

# < a,b | bbaaabbbaaa=a >
bbaaabbbaaa -> a
bbaaaba -> abbbaaa

# < a,b | bbaaabbbaba=a >
bbaaabbbaba -> a

# < a,b | bbaaabbbbba=a >
bbaaabbbbba -> a
bbaaabbba -> aaabbbbba
bbaaaba -> aaabbba

# < a,b | bbaabaaaaaa=a >
bbaabaaaaaa -> a

# < a,b | bbaabaaaaba=a >
bbaabaaaaba -> a

# < a,b | bbaabaaabaa=a >
bbaabaaabaa -> a

# < a,b | bbaabaaabba=a >
bbaabaaabba -> a
bbaabaaaa -> aabaaabba

# < a,b | bbaabaabaaa=a >
bbaabaabaaa -> a

# < a,b | bbaabaababa=a >
bbaabaababa -> a

# < a,b | bbaabaabbaa=a >
bbaabaabbaa -> a
bbaabaaa -> abaabbaa

# < a,b | bbaabaabbba=a >
bbaabaabbba -> a
bbaabaaba -> aabaabbba

# < a,b | bbaababaaaa=a >
bbaababaaaa -> a

# < a,b | bbaababaaba=a >
bbaababaaba -> a

# < a,b | bbaabababaa=a >
bbaabababaa -> a

# < a,b | bbaabababba=a >
bbaabababba -> a
bbaababaa -> aabababba

# < a,b | bbaababbaaa=a >
bbaababbaaa -> a

# < a,b | bbaababbaba=a >
bbaababbaba -> a

# < a,b | bbaababbbaa=a >
bbaababbbaa -> a
bbaababa -> ababbbaa

# < a,b | bbaababbbba=a >
bbaababbbba -> a
bbaababba -> aababbbba
bbaabaa -> aababba

# < a,b | bbaabbaaaaa=a >
bbaabbaaaaa -> a

# < a,b | bbaabbaaaba=a >
bbaabbaaaba -> a

# < a,b | bbaabbaabaa=a >
bbaabbaabaa -> a

# < a,b | bbaabbaabba=a >
bbaabbaabba -> a
bbaaa -> aabba

# < a,b | bbaabbabaaa=a >
bbaabbabaaa -> a

# < a,b | bbaabbababa=a >
bbaabbababa -> a

# < a,b | bbaabbabbaa=a >
bbaabbabbaa -> a
bbaabbaa -> abbabbaa
bbaaa -> abbaa

# < a,b | bbaabbabbba=a >
bbaabbabbba -> a
bbaabbaba -> aabbabbba

# < a,b | bbaabbbaaaa=a >
bbaabbbaaaa -> a

# < a,b | bbaabbbaaba=a >
bbaabbbaaba -> a

# < a,b | bbaabbbabaa=a >
bbaabbbabaa -> a

# < a,b | bbaabbbbaaa=a >
bbaabbbbaaa -> a

# < a,b | bbaabbbbaba=a >
bbaabbbbaba -> a

# < a,b | bbaabbbbbba=a >
bbaabbbbbba -> a
bbaabbbba -> aabbbbbba
bbaabba -> aabbbba
bbaaa -> aabba

# < a,b | bbabaaaaaaa=a >
bbabaaaaaaa -> a

# < a,b | bbabaaaaaba=a >
bbabaaaaaba -> a

# < a,b | bbabaaaabaa=a >
bbabaaaabaa -> a

# < a,b | bbabaaaabba=a >
bbabaaaabba -> a
bbabaaaaa -> abaaaabba

# < a,b | bbabaaabaaa=a >
bbabaaabaaa -> a

# < a,b | bbabaaababa=a >
bbabaaababa -> a

# < a,b | bbabaaabbaa=a >
bbabaaabbaa -> a

# < a,b | bbabaaabbba=a >
bbabaaabbba -> a
bbabaaaba -> abaaabbba

# < a,b | bbabaabaaaa=a >
bbabaabaaaa -> a

# < a,b | bbabaabaaba=a >
bbabaabaaba -> a

# < a,b | bbabaababaa=a >
bbabaababaa -> a

# < a,b | bbabaababba=a >
bbabaababba -> a
bbabaabaa -> abaababba

# < a,b | bbabaabbaaa=a >
bbabaabbaaa -> a

# < a,b | bbabaabbaba=a >
bbabaabbaba -> a
bbabaaa -> aabbaba

# < a,b | bbabaabbbaa=a >
bbabaabbbaa -> a

# < a,b | bbabaabbbba=a >
bbabaabbbba -> a
bbabaabba -> abaabbbba
bbabaaa -> abaabba

# < a,b | bbababaaaaa=a >
bbababaaaaa -> a

# < a,b | bbababaaaba=a >
bbababaaaba -> a

# < a,b | bbababaabaa=a >
bbababaabaa -> a

# < a,b | bbababaabba=a >
bbababaabba -> a
bbababaaa -> ababaabba

# < a,b | bbabababaaa=a >
bbabababaaa -> a

# < a,b | bbababababa=a >
bbababababa -> a

# < a,b | bbabababbaa=a >
bbabababbaa -> a

# < a,b | bbabababbba=a >
bbabababbba -> a
bbabababa -> abababbba

# < a,b | bbababbaaaa=a >
bbababbaaaa -> a

# < a,b | bbababbaaba=a >
bbababbaaba -> a

# < a,b | bbababbabaa=a >
bbababbabaa -> a

# < a,b | bbababbabba=a >
bbababbabba -> a
bbababbaa -> ababbabba

# < a,b | bbababbbaaa=a >
bbababbbaaa -> a

# < a,b | bbababbbaba=a >
bbababbbaba -> a
bbababa -> abbbaba

# < a,b | bbababbbbaa=a >
bbababbbbaa -> a

# < a,b | bbababbbbba=a >
bbababbbbba -> a
bbababbba -> ababbbbba
bbababa -> ababbba

# < a,b | bbabbaaaaaa=a >
bbabbaaaaaa -> a

# < a,b | bbabbaaaaba=a >
bbabbaaaaba -> a

# < a,b | bbabbaaabaa=a >
bbabbaaabaa -> a

# < a,b | bbabbaaabba=a >
bbabbaaabba -> a
bbabbaaaa -> abbaaabba

# < a,b | bbabbaabaaa=a >
bbabbaabaaa -> a

# < a,b | bbabbaababa=a >
bbabbaababa -> a

# < a,b | bbabbaabbaa=a >
bbabbaabbaa -> a

# < a,b | bbabbaabbba=a >
bbabbaabbba -> a
bbabbaaba -> abbaabbba

# < a,b | bbabbabaaaa=a >
bbabbabaaaa -> a

# < a,b | bbabbabaaba=a >
bbabbabaaba -> a

# < a,b | bbabbababaa=a >
bbabbababaa -> a

# < a,b | bbabbababba=a >
bbabbababba -> a
bbabbabaa -> abbababba

# < a,b | bbabbabbaaa=a >
bbabbabbaaa -> a

# < a,b | bbabbabbaba=a >
bbabbabbaba -> a

# < a,b | bbabbabbbaa=a >
bbabbabbbaa -> a

# < a,b | bbabbbaaaaa=a >
bbabbbaaaaa -> a

# < a,b | bbabbbaaaba=a >
bbabbbaaaba -> a

# < a,b | bbabbbaabaa=a >
bbabbbaabaa -> a

# < a,b | bbabbbaabba=a >
bbabbbaabba -> a
bbabbbaaa -> abbbaabba

# < a,b | bbabbbabaaa=a >
bbabbbabaaa -> a

# < a,b | bbabbbababa=a >
bbabbbababa -> a

# < a,b | bbabbbabbaa=a >
bbabbbabbaa -> a

# < a,b | bbabbbabbba=a >
bbabbbabbba -> a
bbaba -> abbba

# < a,b | bbabbbbaaaa=a >
bbabbbbaaaa -> a

# < a,b | bbabbbbaaba=a >
bbabbbbaaba -> a

# < a,b | bbabbbbabaa=a >
bbabbbbabaa -> a

# < a,b | bbabbbbabba=a >
bbabbbbabba -> a
bbabbbbaa -> abbbbabba

# < a,b | bbabbbbbaaa=a >
bbabbbbbaaa -> a

# < a,b | bbabbbbbaba=a >
bbabbbbbaba -> a

# < a,b | bbabbbbbbaa=a >
bbabbbbbbaa -> a

# < a,b | bbabbbbbbba=a >
bbabbbbbbba -> a
bbabbbbba -> abbbbbbba
bbabbba -> abbbbba
bbaba -> abbba

# < a,b | bbbaaaaaaaa=a >
bbbaaaaaaaa -> a

# < a,b | bbbaaaaaaba=a >
bbbaaaaaaba -> a

# < a,b | bbbaaaaabaa=a >
bbbaaaaabaa -> a

# < a,b | bbbaaaaabba=a >
bbbaaaaabba -> a

# < a,b | bbbaaaabaaa=a >
bbbaaaabaaa -> a

# < a,b | bbbaaaababa=a >
bbbaaaababa -> a

# < a,b | bbbaaaabbaa=a >
bbbaaaabbaa -> a

# < a,b | bbbaaaabbba=a >
bbbaaaabbba -> a
bbbaaaaa -> aaaabbba

# < a,b | bbbaaabaaaa=a >
bbbaaabaaaa -> a

# < a,b | bbbaaabaaba=a >
bbbaaabaaba -> a

# < a,b | bbbaaababaa=a >
bbbaaababaa -> a

# < a,b | bbbaaababba=a >
bbbaaababba -> a

# < a,b | bbbaaabbaaa=a >
bbbaaabbaaa -> a

# < a,b | bbbaaabbaba=a >
bbbaaabbaba -> a

# < a,b | bbbaaabbbaa=a >
bbbaaabbbaa -> a
bbbaaaa -> aabbbaa

# < a,b | bbbaaabbbba=a >
bbbaaabbbba -> a
bbbaaaba -> aaabbbba

# < a,b | bbbaabaaaaa=a >
bbbaabaaaaa -> a

# < a,b | bbbaabaaaba=a >
bbbaabaaaba -> a

# < a,b | bbbaabaabaa=a >
bbbaabaabaa -> a

# < a,b | bbbaabaabba=a >
bbbaabaabba -> a

# < a,b | bbbaababaaa=a >
bbbaababaaa -> a

# < a,b | bbbaabababa=a >
bbbaabababa -> a

# < a,b | bbbaababbaa=a >
bbbaababbaa -> a

# < a,b | bbbaababbba=a >
bbbaababbba -> a
bbbaabaa -> aababbba

# < a,b | bbbaabbaaaa=a >
bbbaabbaaaa -> a

# < a,b | bbbaabbaaba=a >
bbbaabbaaba -> a

# < a,b | bbbaabbabaa=a >
bbbaabbabaa -> a

# < a,b | bbbaabbabba=a >
bbbaabbabba -> a

# < a,b | bbbaabbbaaa=a >
bbbaabbbaaa -> a

# < a,b | bbbaabbbaba=a >
bbbaabbbaba -> a

# < a,b | bbbaabbbbaa=a >
bbbaabbbbaa -> a
bbbaaba -> abbbbaa

# < a,b | bbbaabbbbba=a >
bbbaabbbbba -> a
bbbaabba -> aabbbbba

# < a,b | bbbabaaaaaa=a >
bbbabaaaaaa -> a

# < a,b | bbbabaaaaba=a >
bbbabaaaaba -> a

# < a,b | bbbabaaabaa=a >
bbbabaaabaa -> a

# < a,b | bbbabaaabba=a >
bbbabaaabba -> a

# < a,b | bbbabaabaaa=a >
bbbabaabaaa -> a

# < a,b | bbbabaababa=a >
bbbabaababa -> a

# < a,b | bbbabaabbaa=a >
bbbabaabbaa -> a

# < a,b | bbbabaabbba=a >
bbbabaabbba -> a
bbbabaaa -> abaabbba

# < a,b | bbbababaaaa=a >
bbbababaaaa -> a

# < a,b | bbbababaaba=a >
bbbababaaba -> a

# < a,b | bbbabababaa=a >
bbbabababaa -> a

# < a,b | bbbabababba=a >
bbbabababba -> a

# < a,b | bbbababbaaa=a >
bbbababbaaa -> a

# < a,b | bbbababbaba=a >
bbbababbaba -> a

# < a,b | bbbababbbaa=a >
bbbababbbaa -> a

# < a,b | bbbababbbba=a >
bbbababbbba -> a
bbbababa -> ababbbba

# < a,b | bbbabbaaaaa=a >
bbbabbaaaaa -> a

# < a,b | bbbabbaaaba=a >
bbbabbaaaba -> a

# < a,b | bbbabbaabaa=a >
bbbabbaabaa -> a

# < a,b | bbbabbaabba=a >
bbbabbaabba -> a

# < a,b | bbbabbabaaa=a >
bbbabbabaaa -> a

# < a,b | bbbabbababa=a >
bbbabbababa -> a

# < a,b | bbbabbabbaa=a >
bbbabbabbaa -> a

# < a,b | bbbabbabbba=a >
bbbabbabbba -> a
bbbabbaa -> abbabbba

# < a,b | bbbabbbaaaa=a >
bbbabbbaaaa -> a

# < a,b | bbbabbbaaba=a >
bbbabbbaaba -> a

# < a,b | bbbabbbabaa=a >
bbbabbbabaa -> a

# < a,b | bbbabbbabba=a >
bbbabbbabba -> a

# < a,b | bbbabbbbaaa=a >
bbbabbbbaaa -> a

# < a,b | bbbabbbbaba=a >
bbbabbbbaba -> a

# < a,b | bbbabbbbbaa=a >
bbbabbbbbaa -> a

# < a,b | bbbabbbbbba=a >
bbbabbbbbba -> a
bbbabbba -> abbbbbba
bbbaa -> abbba

# < a,b | bbbbaaaaaaa=a >
bbbbaaaaaaa -> a

# < a,b | bbbbaaaaaba=a >
bbbbaaaaaba -> a

# < a,b | bbbbaaaabaa=a >
bbbbaaaabaa -> a

# < a,b | bbbbaaaabba=a >
bbbbaaaabba -> a

# < a,b | bbbbaaabaaa=a >
bbbbaaabaaa -> a

# < a,b | bbbbaaababa=a >
bbbbaaababa -> a

# < a,b | bbbbaaabbaa=a >
bbbbaaabbaa -> a

# < a,b | bbbbaaabbba=a >
bbbbaaabbba -> a

# < a,b | bbbbaabaaaa=a >
bbbbaabaaaa -> a

# < a,b | bbbbaabaaba=a >
bbbbaabaaba -> a

# < a,b | bbbbaababaa=a >
bbbbaababaa -> a

# < a,b | bbbbaababba=a >
bbbbaababba -> a

# < a,b | bbbbaabbaaa=a >
bbbbaabbaaa -> a

# < a,b | bbbbaabbaba=a >
bbbbaabbaba -> a

# < a,b | bbbbaabbbaa=a >
bbbbaabbbaa -> a

# < a,b | bbbbaabbbba=a >
bbbbaabbbba -> a
bbbbaaa -> aabbbba

# < a,b | bbbbabaaaaa=a >
bbbbabaaaaa -> a

# < a,b | bbbbabaaaba=a >
bbbbabaaaba -> a

# < a,b | bbbbabaabaa=a >
bbbbabaabaa -> a

# < a,b | bbbbabaabba=a >
bbbbabaabba -> a

# < a,b | bbbbababaaa=a >
bbbbababaaa -> a

# < a,b | bbbbabababa=a >
bbbbabababa -> a

# < a,b | bbbbababbaa=a >
bbbbababbaa -> a

# < a,b | bbbbababbba=a >
bbbbababbba -> a

# < a,b | bbbbabbaaaa=a >
bbbbabbaaaa -> a

# < a,b | bbbbabbaaba=a >
bbbbabbaaba -> a

# < a,b | bbbbabbabaa=a >
bbbbabbabaa -> a

# < a,b | bbbbabbabba=a >
bbbbabbabba -> a

# < a,b | bbbbabbbaaa=a >
bbbbabbbaaa -> a

# < a,b | bbbbabbbaba=a >
bbbbabbbaba -> a

# < a,b | bbbbabbbbaa=a >
bbbbabbbbaa -> a

# < a,b | bbbbabbbbba=a >
bbbbabbbbba -> a
bbbbaba -> abbbbba

# < a,b | bbbbbaaaaaa=a >
bbbbbaaaaaa -> a

# < a,b | bbbbbaaaaba=a >
bbbbbaaaaba -> a

# < a,b | bbbbbaaabaa=a >
bbbbbaaabaa -> a

# < a,b | bbbbbaaabba=a >
bbbbbaaabba -> a

# < a,b | bbbbbaabaaa=a >
bbbbbaabaaa -> a

# < a,b | bbbbbaababa=a >
bbbbbaababa -> a

# < a,b | bbbbbaabbaa=a >
bbbbbaabbaa -> a

# < a,b | bbbbbaabbba=a >
bbbbbaabbba -> a

# < a,b | bbbbbabaaaa=a >
bbbbbabaaaa -> a

# < a,b | bbbbbabaaba=a >
bbbbbabaaba -> a

# < a,b | bbbbbababaa=a >
bbbbbababaa -> a

# < a,b | bbbbbababba=a >
bbbbbababba -> a

# < a,b | bbbbbabbaaa=a >
bbbbbabbaaa -> a

# < a,b | bbbbbabbaba=a >
bbbbbabbaba -> a

# < a,b | bbbbbabbbaa=a >
bbbbbabbbaa -> a

# < a,b | bbbbbabbbba=a >
bbbbbabbbba -> a

# < a,b | bbbbbbaaaaa=a >
bbbbbbaaaaa -> a

# < a,b | bbbbbbaaaba=a >
bbbbbbaaaba -> a

# < a,b | bbbbbbaabaa=a >
bbbbbbaabaa -> a

# < a,b | bbbbbbaabba=a >
bbbbbbaabba -> a

# < a,b | bbbbbbabaaa=a >
bbbbbbabaaa -> a

# < a,b | bbbbbbababa=a >
bbbbbbababa -> a

# < a,b | bbbbbbabbaa=a >
bbbbbbabbaa -> a

# < a,b | bbbbbbabbba=a >
bbbbbbabbba -> a

# < a,b | bbbbbbbaaaa=a >
bbbbbbbaaaa -> a

# < a,b | bbbbbbbaaba=a >
bbbbbbbaaba -> a

# < a,b | bbbbbbbabaa=a >
bbbbbbbabaa -> a

# < a,b | bbbbbbbabba=a >
bbbbbbbabba -> a

# < a,b | bbbbbbbbaaa=a >
bbbbbbbbaaa -> a

# < a,b | bbbbbbbbaba=a >
bbbbbbbbaba -> a

# < a,b | bbbbbbbbbaa=a >
bbbbbbbbbaa -> a

# < a,b | bbbbbbbbbba=a >
bbbbbbbbbba -> a

# < a,b | baaaaaaaaaaa=a >
baaaaaaaaaaa -> a

# < a,b | baaaaaaaaaba=a >
baaaaaaaaaba -> a
baaaaaaaaaa -> aaaaaaaaaba

# < a,b | baaaaaaaabaa=a >
baaaaaaaabaa -> a
baaaaaaaaa -> aaaaaaabaa

# < a,b | baaaaaaaabba=a >
baaaaaaaabba -> a
baaaaaaaaba -> aaaaaaaabba
baaaaaaaaa -> aaaaaaaaba

# < a,b | baaaaaaabaaa=a >
baaaaaaabaaa -> a
baaaaaaaa -> aaaaabaaa

# < a,b | baaaaaaabbba=a >
baaaaaaabbba -> a
baaaaaaabba -> aaaaaaabbba
baaaaaaaba -> aaaaaaabba
baaaaaaaa -> aaaaaaaba

# < a,b | baaaaaabaaaa=a >
baaaaaabaaaa -> a
baaaaaaa -> aaabaaaa

# < a,b | baaaaaababaa=a >
baaaaaababaa -> a
baaaaaabaa -> aaaaababaa
baaaaaaa -> aaaaabaa

# < a,b | baaaaaabbbba=a >
baaaaaabbbba -> a
baaaaaabbba -> aaaaaabbbba
baaaaaabba -> aaaaaabbba
baaaaaaba -> aaaaaabba
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaaaaa=a >
baaaaabaaaaa -> a
baaaaaa -> abaaaaa

# < a,b | baaaaabbbbba=a >
baaaaabbbbba -> a
baaaaabbbba -> aaaaabbbbba
baaaaabbba -> aaaaabbbba
baaaaabba -> aaaaabbba
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaaaaa=a >
baaaabaaaaaa -> a

# < a,b | baaaabaaaaba=a >
baaaabaaaaba -> a
baaaaa -> aaaaba

# < a,b | baaaabaabaaa=a >
baaaabaabaaa -> a
baaaabaaa -> aabaabaaa
baaaaa -> aabaaa

# < a,b | baaaabababaa=a >
baaaabababaa -> a
baaaababaa -> aaabababaa
baaaabaa -> aaababaa
baaaaa -> aaabaa

# < a,b | baaaabbaaaaa=a >
baaaabbaaaaa -> a

# < a,b | baaaabbbbbba=a >
baaaabbbbbba -> a
baaaabbbbba -> aaaabbbbbba
baaaabbbba -> aaaabbbbba
baaaabbba -> aaaabbbba
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaaaaa=a >
baaabaaaaaaa -> a

# < a,b | baaabaaaaaba=a >
baaabaaaaaba -> a
baaabaaaaaa -> aaabaaaaaba

# < a,b | baaabaaaabaa=a >
baaabaaaabaa -> a
baaabaaaaa -> aabaaaabaa

# < a,b | baaabaaaabba=a >
baaabaaaabba -> a
baaabaaaaba -> aaabaaaabba
baaabaaaaa -> aaabaaaaba

# < a,b | baaabaaabaaa=a >
baaabaaabaaa -> a
baaaa -> abaaa

# < a,b | baaabaabaaaa=a >
baaabaabaaaa -> a

# < a,b | baaababaaaaa=a >
baaababaaaaa -> a

# < a,b | baaababbaaaa=a >
baaababbaaaa -> a

# < a,b | baaabbaaaaaa=a >
baaabbaaaaaa -> a

# < a,b | baaabbaaaaba=a >
baaabbaaaaba -> a
baaabbaaaaa -> aaabbaaaaba

# < a,b | baaabbaaabaa=a >
baaabbaaabaa -> a
baaabbaaaa -> aabbaaabaa

# < a,b | baaabbaaabba=a >
baaabbaaabba -> a
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baaabbabaaaa=a >
baaabbabaaaa -> a

# < a,b | baaabbbaaaaa=a >
baaabbbaaaaa -> a

# < a,b | baaabbbaaaba=a >
baaabbbaaaba -> a
baaabbbaaaa -> aaabbbaaaba

# < a,b | baaabbbbaaaa=a >
baaabbbbaaaa -> a

# < a,b | baaabbbbbbba=a >
baaabbbbbbba -> a
baaabbbbbba -> aaabbbbbbba
baaabbbbba -> aaabbbbbba
baaabbbba -> aaabbbbba
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaaaaa=a >
baabaaaaaaaa -> a

# < a,b | baabaaaaaaba=a >
baabaaaaaaba -> a
baabaaaaaaa -> aabaaaaaaba

# < a,b | baabaaaaabaa=a >
baabaaaaabaa -> a
baabaaaaaa -> abaaaaabaa

# < a,b | baabaaaaabba=a >
baabaaaaabba -> a
baabaaaaaba -> aabaaaaabba
baabaaaaaa -> aabaaaaaba

# < a,b | baabaaaabaaa=a >
baabaaaabaaa -> a

# < a,b | baabaaaabbba=a >
baabaaaabbba -> a
baabaaaabba -> aabaaaabbba
baabaaaaba -> aabaaaabba
baabaaaaa -> aabaaaaba

# < a,b | baabaaabaaaa=a >
baabaaabaaaa -> a

# < a,b | baabaaabaaba=a >
baabaaabaaba -> a
baabaaabaaa -> aabaaabaaba
baabaaaa -> aaabaaba

# < a,b | baabaaababaa=a >
baabaaababaa -> a
baabaaabaa -> abaaababaa
baabaaaa -> abaaabaa

# < a,b | baabaaabbaaa=a >
baabaaabbaaa -> a

# < a,b | baabaaabbbba=a >
baabaaabbbba -> a
baabaaabbba -> aabaaabbbba
baabaaabba -> aabaaabbba
baabaaaba -> aabaaabba
baabaaaa -> aabaaaba

# < a,b | baabaabaaaaa=a >
baabaabaaaaa -> a

# < a,b | baabaabaaaba=a >
baabaabaaaba -> a
baabaabaaaa -> aabaabaaaba

# < a,b | baabaabaabaa=a >
baabaabaabaa -> a
baaa -> abaa

# < a,b | baabaababaaa=a >
baabaababaaa -> a

# < a,b | baabaabbaaaa=a >
baabaabbaaaa -> a

# < a,b | baabaabbaaba=a >
baabaabbaaba -> a
baabaaba -> aabbaaba
baaa -> aaba

# < a,b | baabaabbbaaa=a >
baabaabbbaaa -> a

# < a,b | baababaaaaaa=a >
baababaaaaaa -> a

# < a,b | baababaaaaba=a >
baababaaaaba -> a
baababaaaaa -> aababaaaaba

# < a,b | baababaaabaa=a >
baababaaabaa -> a
baababaaaa -> ababaaabaa

# < a,b | baababaaabba=a >
baababaaabba -> a
baababaaaba -> aababaaabba
baababaaaa -> aababaaaba

# < a,b | baababaabaaa=a >
baababaabaaa -> a

# < a,b | baabababaaaa=a >
baabababaaaa -> a

# < a,b | baababababaa=a >
baababababaa -> a
baabababaa -> ababababaa
baababaa -> abababaa
baabaa -> ababaa
baaa -> abaa

# < a,b | baabababbaaa=a >
baabababbaaa -> a

# < a,b | baababbaaaaa=a >
baababbaaaaa -> a

# < a,b | baababbaaaba=a >
baababbaaaba -> a
baababbaaaa -> aababbaaaba

# < a,b | baababbaabaa=a >
baababbaabaa -> a
baababbaaa -> ababbaabaa

# < a,b | baababbabaaa=a >
baababbabaaa -> a

# < a,b | baababbbaaaa=a >
baababbbaaaa -> a

# < a,b | baababbbbaaa=a >
baababbbbaaa -> a

# < a,b | baabbaaaaaaa=a >
baabbaaaaaaa -> a

# < a,b | baabbaaaaaba=a >
baabbaaaaaba -> a
baabbaaaaaa -> aabbaaaaaba

# < a,b | baabbaaaabaa=a >
baabbaaaabaa -> a
baabbaaaaa -> abbaaaabaa

# < a,b | baabbaaaabba=a >
baabbaaaabba -> a
baabbaaaaba -> aabbaaaabba
baabbaaaaa -> aabbaaaaba

# < a,b | baabbaaabaaa=a >
baabbaaabaaa -> a

# < a,b | baabbaaabbba=a >
baabbaaabbba -> a
baabbaaabba -> aabbaaabbba
baabbaaaba -> aabbaaabba
baabbaaaa -> aabbaaaba

# < a,b | baabbaabaaaa=a >
baabbaabaaaa -> a

# < a,b | baabbaabaaba=a >
baabbaabaaba -> a
baabbaabaaa -> aabbaabaaba

# < a,b | baabbaababaa=a >
baabbaababaa -> a
baabbaabaa -> abbaababaa
baabbaaa -> abbaabaa

# < a,b | baabbaabbaaa=a >
baabbaabbaaa -> a

# < a,b | baabbabaaaaa=a >
baabbabaaaaa -> a

# < a,b | baabbabaaaba=a >
baabbabaaaba -> a
baabbabaaaa -> aabbabaaaba

# < a,b | baabbabaabaa=a >
baabbabaabaa -> a
baabbabaaa -> abbabaabaa

# < a,b | baabbababaaa=a >
baabbababaaa -> a

# < a,b | baabbabbaaaa=a >
baabbabbaaaa -> a

# < a,b | baabbabbaaba=a >
baabbabbaaba -> a
baabbabbaaa -> aabbabbaaba

# < a,b | baabbabbbaaa=a >
baabbabbbaaa -> a

# < a,b | baabbbaaaaaa=a >
baabbbaaaaaa -> a

# < a,b | baabbbaaaaba=a >
baabbbaaaaba -> a
baabbbaaaaa -> aabbbaaaaba

# < a,b | baabbbaaabaa=a >
baabbbaaabaa -> a
baabbbaaaa -> abbbaaabaa

# < a,b | baabbbaaabba=a >
baabbbaaabba -> a
baabbbaaaba -> aabbbaaabba
baabbbaaaa -> aabbbaaaba

# < a,b | baabbbaabaaa=a >
baabbbaabaaa -> a

# < a,b | baabbbaabbba=a >
baabbbaabbba -> a
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | baabbbabaaaa=a >
baabbbabaaaa -> a

# < a,b | baabbbabaaba=a >
baabbbabaaba -> a
baabbbabaaa -> aabbbabaaba

# < a,b | baabbbabbaaa=a >
baabbbabbaaa -> a

# < a,b | baabbbbaaaaa=a >
baabbbbaaaaa -> a

# < a,b | baabbbbaaaba=a >
baabbbbaaaba -> a
baabbbbaaaa -> aabbbbaaaba

# < a,b | baabbbbaabaa=a >
baabbbbaabaa -> a
baabbbbaaa -> abbbbaabaa

# < a,b | baabbbbaabba=a >
baabbbbaabba -> a
baabbbbaaba -> aabbbbaabba
baabbbbaaa -> aabbbbaaba

# < a,b | baabbbbabaaa=a >
baabbbbabaaa -> a

# < a,b | baabbbbbaaaa=a >
baabbbbbaaaa -> a

# < a,b | baabbbbbaaba=a >
baabbbbbaaba -> a
baabbbbbaaa -> aabbbbbaaba

# < a,b | baabbbbbbaaa=a >
baabbbbbbaaa -> a

# < a,b | baabbbbbbbba=a >
baabbbbbbbba -> a
baabbbbbbba -> aabbbbbbbba
baabbbbbba -> aabbbbbbba
baabbbbba -> aabbbbbba
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaaaaa=a >
babaaaaaaaaa -> a

# < a,b | babaaaaaaaba=a >
babaaaaaaaba -> a
babaaaaaaaa -> abaaaaaaaba

# < a,b | babaaaaaabaa=a >
babaaaaaabaa -> a

# < a,b | babaaaaaabba=a >
babaaaaaabba -> a
babaaaaaaba -> abaaaaaabba
babaaaaaaa -> abaaaaaaba

# < a,b | babaaaaabaaa=a >
babaaaaabaaa -> a

# < a,b | babaaaaababa=a >
babaaaaababa -> a
babaaaaabaa -> abaaaaababa
babaaaaaa -> aaaaababa

# < a,b | babaaaaabbaa=a >
babaaaaabbaa -> a

# < a,b | babaaaaabbba=a >
babaaaaabbba -> a
babaaaaabba -> abaaaaabbba
babaaaaaba -> abaaaaabba
babaaaaaa -> abaaaaaba

# < a,b | babaaaabaaaa=a >
babaaaabaaaa -> a

# < a,b | babaaaabaaba=a >
babaaaabaaba -> a
babaaaabaaa -> abaaaabaaba

# < a,b | babaaaababaa=a >
babaaaababaa -> a
babaaaaa -> aaababaa

# < a,b | babaaaabbaaa=a >
babaaaabbaaa -> a

# < a,b | babaaaabbaba=a >
babaaaabbaba -> a
babaaaabbaa -> abaaaabbaba
babaaaaba -> aaaabbaba
babaaaaa -> aaaabbaa

# < a,b | babaaaabbbaa=a >
babaaaabbbaa -> a

# < a,b | babaaaabbbba=a >
babaaaabbbba -> a
babaaaabbba -> abaaaabbbba
babaaaabba -> abaaaabbba
babaaaaba -> abaaaabba
babaaaaa -> abaaaaba

# < a,b | babaaabaaaaa=a >
babaaabaaaaa -> a

# < a,b | babaaabaaaba=a >
babaaabaaaba -> a
babaaabaaaa -> abaaabaaaba

# < a,b | babaaabaabaa=a >
babaaabaabaa -> a

# < a,b | babaaabaabba=a >
babaaabaabba -> a
babaaabaaba -> abaaabaabba
babaaabaaa -> abaaabaaba

# < a,b | babaaababaaa=a >
babaaababaaa -> a
babaaaa -> ababaaa

# < a,b | babaaababbaa=a >
babaaababbaa -> a

# < a,b | babaaabbaaaa=a >
babaaabbaaaa -> a

# < a,b | babaaabbaaba=a >
babaaabbaaba -> a
babaaabbaaa -> abaaabbaaba

# < a,b | babaaabbbaaa=a >
babaaabbbaaa -> a

# < a,b | babaaabbbbaa=a >
babaaabbbbaa -> a

# < a,b | babaaabbbbba=a >
babaaabbbbba -> a
babaaabbbba -> abaaabbbbba
babaaabbba -> abaaabbbba
babaaabba -> abaaabbba
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaaaaa=a >
babaabaaaaaa -> a

# < a,b | babaabaaaaba=a >
babaabaaaaba -> a
babaabaaaaa -> abaabaaaaba

# < a,b | babaabaaabaa=a >
babaabaaabaa -> a

# < a,b | babaabaaabba=a >
babaabaaabba -> a
babaabaaaba -> abaabaaabba
babaabaaaa -> abaabaaaba

# < a,b | babaabaabaaa=a >
babaabaabaaa -> a

# < a,b | babaabaababa=a >
babaabaababa -> a
babaabaabaa -> abaabaababa
babaabaaa -> aabaababa

# < a,b | babaabaabbaa=a >
babaabaabbaa -> a

# < a,b | babaabaabbba=a >
babaabaabbba -> a
babaabaabba -> abaabaabbba
babaabaaba -> abaabaabba
babaabaaa -> abaabaaba

# < a,b | babaababaaaa=a >
babaababaaaa -> a

# < a,b | babaababaaba=a >
babaababaaba -> a
babaaa -> abaaba

# < a,b | babaabababaa=a >
babaabababaa -> a
babaabaa -> abababaa

# < a,b | babaababbaaa=a >
babaababbaaa -> a

# < a,b | babaababbaba=a >
babaababbaba -> a
babaababbaa -> abaababbaba
babaababa -> aababbaba
babaabaa -> aababbaa
babaaa -> aababa

# < a,b | babaababbbaa=a >
babaababbbaa -> a

# < a,b | babaabbaaaaa=a >
babaabbaaaaa -> a

# < a,b | babaabbaaaba=a >
babaabbaaaba -> a
babaabbaaaa -> abaabbaaaba

# < a,b | babaabbaabaa=a >
babaabbaabaa -> a

# < a,b | babaabbaabba=a >
babaabbaabba -> a
babaabbaaba -> abaabbaabba
babaabbaaa -> abaabbaaba

# < a,b | babaabbabaaa=a >
babaabbabaaa -> a

# < a,b | babaabbabbaa=a >
babaabbabbaa -> a

# < a,b | babaabbbaaaa=a >
babaabbbaaaa -> a

# < a,b | babaabbbaaba=a >
babaabbbaaba -> a
babaabbbaaa -> abaabbbaaba

# < a,b | babaabbbbaaa=a >
babaabbbbaaa -> a

# < a,b | babaabbbbbaa=a >
babaabbbbbaa -> a

# < a,b | babaabbbbbba=a >
babaabbbbbba -> a
babaabbbbba -> abaabbbbbba
babaabbbba -> abaabbbbba
babaabbba -> abaabbbba
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaaaaa=a >
bababaaaaaaa -> a

# < a,b | bababaaaaaba=a >
bababaaaaaba -> a
bababaaaaaa -> ababaaaaaba

# < a,b | bababaaaabaa=a >
bababaaaabaa -> a

# < a,b | bababaaaabba=a >
bababaaaabba -> a
bababaaaaba -> ababaaaabba
bababaaaaa -> ababaaaaba

# < a,b | bababaaabaaa=a >
bababaaabaaa -> a

# < a,b | bababaaababa=a >
bababaaababa -> a
bababaaabaa -> ababaaababa
bababaaaa -> abaaababa

# < a,b | bababaaabbaa=a >
bababaaabbaa -> a

# < a,b | bababaaabbba=a >
bababaaabbba -> a
bababaaabba -> ababaaabbba
bababaaaba -> ababaaabba
bababaaaa -> ababaaaba

# < a,b | bababaabaaaa=a >
bababaabaaaa -> a

# < a,b | bababaabaaba=a >
bababaabaaba -> a
bababaabaaa -> ababaabaaba

# < a,b | bababaababaa=a >
bababaababaa -> a

# < a,b | bababaabbaaa=a >
bababaabbaaa -> a

# < a,b | bababaabbaba=a >
bababaabbaba -> a
bababaabbaa -> ababaabbaba
bababaaba -> abaabbaba
bababaaa -> abaabbaa

# < a,b | bababaabbbaa=a >
bababaabbbaa -> a

# < a,b | bababaabbbba=a >
bababaabbbba -> a
bababaabbba -> ababaabbbba
bababaabba -> ababaabbba
bababaaba -> ababaabba
bababaaa -> ababaaba

# < a,b | babababaaaaa=a >
babababaaaaa -> a

# < a,b | babababaaaba=a >
babababaaaba -> a
babababaaaa -> abababaaaba

# < a,b | babababaabaa=a >
babababaabaa -> a

# < a,b | babababaabba=a >
babababaabba -> a
babababaaba -> abababaabba
babababaaa -> abababaaba

# < a,b | bababababaaa=a >
bababababaaa -> a

# < a,b | babababababa=a >
babababababa -> a
baa -> aba

# < a,b | bababababbaa=a >
bababababbaa -> a

# < a,b | babababbaaaa=a >
babababbaaaa -> a

# < a,b | babababbaaba=a >
babababbaaba -> a
babababbaaa -> abababbaaba

# < a,b | babababbabaa=a >
babababbabaa -> a

# < a,b | babababbbaaa=a >
babababbbaaa -> a

# < a,b | babababbbbaa=a >
babababbbbaa -> a

# < a,b | bababbaaaaaa=a >
bababbaaaaaa -> a

# < a,b | bababbaaaaba=a >
bababbaaaaba -> a
bababbaaaaa -> ababbaaaaba

# < a,b | bababbaaabaa=a >
bababbaaabaa -> a

# < a,b | bababbaaabba=a >
bababbaaabba -> a
bababbaaaba -> ababbaaabba
bababbaaaa -> ababbaaaba

# < a,b | bababbaabaaa=a >
bababbaabaaa -> a

# < a,b | bababbaababa=a >
bababbaababa -> a
bababbaabaa -> ababbaababa
bababbaaa -> abbaababa

# < a,b | bababbaabbaa=a >
bababbaabbaa -> a

# < a,b | bababbaabbba=a >
bababbaabbba -> a
bababbaabba -> ababbaabbba
bababbaaba -> ababbaabba
bababbaaa -> ababbaaba

# < a,b | bababbabaaaa=a >
bababbabaaaa -> a

# < a,b | bababbabaaba=a >
bababbabaaba -> a
bababbabaaa -> ababbabaaba

# < a,b | bababbababaa=a >
bababbababaa -> a

# < a,b | bababbabbaaa=a >
bababbabbaaa -> a

# < a,b | bababbabbaba=a >
bababbabbaba -> a
bababbaba -> abbabbaba
bababa -> abbaba
baa -> aba

# < a,b | bababbabbbaa=a >
bababbabbbaa -> a

# < a,b | bababbbaaaaa=a >
bababbbaaaaa -> a

# < a,b | bababbbaaaba=a >
bababbbaaaba -> a
bababbbaaaa -> ababbbaaaba

# < a,b | bababbbaabaa=a >
bababbbaabaa -> a

# < a,b | bababbbaabba=a >
bababbbaabba -> a
bababbbaaba -> ababbbaabba
bababbbaaa -> ababbbaaba

# < a,b | bababbbabaaa=a >
bababbbabaaa -> a

# < a,b | bababbbababa=a >
bababbbababa -> a
bababbbabaa -> ababbbababa
bababbbaa -> abbbababa

# < a,b | bababbbabbaa=a >
bababbbabbaa -> a

# < a,b | bababbbbaaaa=a >
bababbbbaaaa -> a

# < a,b | bababbbbaaba=a >
bababbbbaaba -> a
bababbbbaaa -> ababbbbaaba

# < a,b | bababbbbabaa=a >
bababbbbabaa -> a

# < a,b | bababbbbbaaa=a >
bababbbbbaaa -> a

# < a,b | bababbbbbbaa=a >
bababbbbbbaa -> a

# < a,b | babbaaaaaaaa=a >
babbaaaaaaaa -> a

# < a,b | babbaaaaaaba=a >
babbaaaaaaba -> a
babbaaaaaaa -> abbaaaaaaba

# < a,b | babbaaaaabaa=a >
babbaaaaabaa -> a

# < a,b | babbaaaaabba=a >
babbaaaaabba -> a
babbaaaaaba -> abbaaaaabba
babbaaaaaa -> abbaaaaaba

# < a,b | babbaaaabaaa=a >
babbaaaabaaa -> a

# < a,b | babbaaaababa=a >
babbaaaababa -> a
babbaaaabaa -> abbaaaababa

# < a,b | babbaaaabbaa=a >
babbaaaabbaa -> a

# < a,b | babbaaaabbba=a >
babbaaaabbba -> a
babbaaaabba -> abbaaaabbba
babbaaaaba -> abbaaaabba
babbaaaaa -> abbaaaaba

# < a,b | babbaaabaaaa=a >
babbaaabaaaa -> a

# < a,b | babbaaabaaba=a >
babbaaabaaba -> a
babbaaabaaa -> abbaaabaaba

# < a,b | babbaaababaa=a >
babbaaababaa -> a

# < a,b | babbaaababba=a >
babbaaababba -> a
babbaaababa -> abbaaababba
babbaaaa -> aaababba
babbaaabaa -> abbaaababa

# < a,b | babbaaabbaaa=a >
babbaaabbaaa -> a

# < a,b | babbaaabbaba=a >
babbaaabbaba -> a
babbaaabbaa -> abbaaabbaba

# < a,b | babbaaabbbaa=a >
babbaaabbbaa -> a

# < a,b | babbaaabbbba=a >
babbaaabbbba -> a
babbaaabbba -> abbaaabbbba
babbaaabba -> abbaaabbba
babbaaaba -> abbaaabba
babbaaaa -> abbaaaba

# < a,b | babbaabaaaaa=a >
babbaabaaaaa -> a

# < a,b | babbaabaaaba=a >
babbaabaaaba -> a
babbaabaaaa -> abbaabaaaba

# < a,b | babbaabaabaa=a >
babbaabaabaa -> a

# < a,b | babbaabaabba=a >
babbaabaabba -> a
babbaabaaba -> abbaabaabba
babbaabaaa -> abbaabaaba

# < a,b | babbaababaaa=a >
babbaababaaa -> a

# < a,b | babbaabababa=a >
babbaabababa -> a
babbaababaa -> abbaabababa

# < a,b | babbaababbaa=a >
babbaababbaa -> a
babbaaa -> ababbaa

# < a,b | babbaabbaaaa=a >
babbaabbaaaa -> a

# < a,b | babbaabbaaba=a >
babbaabbaaba -> a
babbaabbaaa -> abbaabbaaba

# < a,b | babbaabbabaa=a >
babbaabbabaa -> a

# < a,b | babbaabbabba=a >
babbaabbabba -> a
babbaabbaba -> abbaabbabba
babbaaba -> aabbabba
babbaabbaa -> abbaabbaba
babbaaa -> aabbaba

# < a,b | babbaabbbaaa=a >
babbaabbbaaa -> a

# < a,b | babbaabbbaba=a >
babbaabbbaba -> a
babbaabbbaa -> abbaabbbaba

# < a,b | babbaabbbbaa=a >
babbaabbbbaa -> a

# < a,b | babbaabbbbba=a >
babbaabbbbba -> a
babbaabbbba -> abbaabbbbba
babbaabbba -> abbaabbbba
babbaabba -> abbaabbba
babbaaba -> abbaabba
babbaaa -> abbaaba

# < a,b | babbabaaaaaa=a >
babbabaaaaaa -> a

# < a,b | babbabaaaaba=a >
babbabaaaaba -> a
babbabaaaaa -> abbabaaaaba

# < a,b | babbabaaabaa=a >
babbabaaabaa -> a

# < a,b | babbabaaabba=a >
babbabaaabba -> a
babbabaaaba -> abbabaaabba
babbabaaaa -> abbabaaaba

# < a,b | babbabaabaaa=a >
babbabaabaaa -> a

# < a,b | babbabaababa=a >
babbabaababa -> a
babbabaabaa -> abbabaababa

# < a,b | babbabaabbaa=a >
babbabaabbaa -> a

# < a,b | babbabaabbba=a >
babbabaabbba -> a
babbabaabba -> abbabaabbba
babbabaaba -> abbabaabba
babbabaaa -> abbabaaba

# < a,b | babbababaaaa=a >
babbababaaaa -> a

# < a,b | babbababaaba=a >
babbababaaba -> a
babbababaaa -> abbababaaba

# < a,b | babbabababaa=a >
babbabababaa -> a

# < a,b | babbabababba=a >
babbabababba -> a
babbabababa -> abbabababba
babbabaa -> abababba
babbababaa -> abbabababa

# < a,b | babbababbaaa=a >
babbababbaaa -> a

# < a,b | babbababbaba=a >
babbababbaba -> a
babbaa -> abbaba

# < a,b | babbababbbaa=a >
babbababbbaa -> a

# < a,b | babbabbaaaaa=a >
babbabbaaaaa -> a

# < a,b | babbabbaaaba=a >
babbabbaaaba -> a
babbabbaaaa -> abbabbaaaba

# < a,b | babbabbaabaa=a >
babbabbaabaa -> a

# < a,b | babbabbaabba=a >
babbabbaabba -> a
babbabbaaba -> abbabbaabba
babbabbaaa -> abbabbaaba

# < a,b | babbabbabaaa=a >
babbabbabaaa -> a

# < a,b | babbabbababa=a >
babbabbababa -> a
babbabbabaa -> abbabbababa

# < a,b | babbabbabbaa=a >
babbabbabbaa -> a

# < a,b | babbabbbaaaa=a >
babbabbbaaaa -> a

# < a,b | babbabbbaaba=a >
babbabbbaaba -> a
babbabbbaaa -> abbabbbaaba

# < a,b | babbabbbabaa=a >
babbabbbabaa -> a

# < a,b | babbabbbabba=a >
babbabbbabba -> a
babbabba -> abbbabba
baba -> abba
baa -> aba

# < a,b | babbabbbbaaa=a >
babbabbbbaaa -> a

# < a,b | babbabbbbaba=a >
babbabbbbaba -> a
babbabbbbaa -> abbabbbbaba

# < a,b | babbabbbbbaa=a >
babbabbbbbaa -> a

# < a,b | babbbaaaaaaa=a >
babbbaaaaaaa -> a

# < a,b | babbbaaaaaba=a >
babbbaaaaaba -> a
babbbaaaaaa -> abbbaaaaaba

# < a,b | babbbaaaabaa=a >
babbbaaaabaa -> a

# < a,b | babbbaaaabba=a >
babbbaaaabba -> a
babbbaaaaba -> abbbaaaabba
babbbaaaaa -> abbbaaaaba

# < a,b | babbbaaabaaa=a >
babbbaaabaaa -> a

# < a,b | babbbaaababa=a >
babbbaaababa -> a
babbbaaabaa -> abbbaaababa

# < a,b | babbbaaabbaa=a >
babbbaaabbaa -> a

# < a,b | babbbaaabbba=a >
babbbaaabbba -> a
babbbaaabba -> abbbaaabbba
babbbaaaba -> abbbaaabba
babbbaaaa -> abbbaaaba

# < a,b | babbbaabaaaa=a >
babbbaabaaaa -> a

# < a,b | babbbaabaaba=a >
babbbaabaaba -> a
babbbaabaaa -> abbbaabaaba

# < a,b | babbbaababaa=a >
babbbaababaa -> a

# < a,b | babbbaababba=a >
babbbaababba -> a
babbbaababa -> abbbaababba
babbbaabaa -> abbbaababa

# < a,b | babbbaabbaaa=a >
babbbaabbaaa -> a

# < a,b | babbbaabbaba=a >
babbbaabbaba -> a
babbbaabbaa -> abbbaabbaba

# < a,b | babbbaabbbaa=a >
babbbaabbbaa -> a

# < a,b | babbbaabbbba=a >
babbbaabbbba -> a
babbbaabbba -> abbbaabbbba
babbbaabba -> abbbaabbba
babbbaaba -> abbbaabba
babbbaaa -> abbbaaba

# < a,b | babbbabaaaaa=a >
babbbabaaaaa -> a

# < a,b | babbbabaaaba=a >
babbbabaaaba -> a
babbbabaaaa -> abbbabaaaba

# < a,b | babbbabaabaa=a >
babbbabaabaa -> a

# < a,b | babbbabaabba=a >
babbbabaabba -> a
babbbabaaba -> abbbabaabba
babbbabaaa -> abbbabaaba

# < a,b | babbbababaaa=a >
babbbababaaa -> a

# < a,b | babbbabababa=a >
babbbabababa -> a
babbbababaa -> abbbabababa

# < a,b | babbbababbaa=a >
babbbababbaa -> a

# < a,b | babbbababbba=a >
babbbababbba -> a
babbbababba -> abbbababbba
babbbaa -> ababbba
babbbababa -> abbbababba
babbbabaa -> abbbababa

# < a,b | babbbabbaaaa=a >
babbbabbaaaa -> a

# < a,b | babbbabbaaba=a >
babbbabbaaba -> a
babbbabbaaa -> abbbabbaaba

# < a,b | babbbabbabaa=a >
babbbabbabaa -> a

# < a,b | babbbabbabba=a >
babbbabbabba -> a
babbbabbaba -> abbbabbabba
babbbabbaa -> abbbabbaba

# < a,b | babbbabbbaaa=a >
babbbabbbaaa -> a

# < a,b | babbbabbbaba=a >
babbbabbbaba -> a
babbbabbbaa -> abbbabbbaba

# < a,b | babbbabbbbaa=a >
babbbabbbbaa -> a

# < a,b | babbbbaaaaaa=a >
babbbbaaaaaa -> a

# < a,b | babbbbaaaaba=a >
babbbbaaaaba -> a
babbbbaaaaa -> abbbbaaaaba

# < a,b | babbbbaaabaa=a >
babbbbaaabaa -> a

# < a,b | babbbbaaabba=a >
babbbbaaabba -> a
babbbbaaaba -> abbbbaaabba
babbbbaaaa -> abbbbaaaba

# < a,b | babbbbaabaaa=a >
babbbbaabaaa -> a

# < a,b | babbbbaababa=a >
babbbbaababa -> a
babbbbaabaa -> abbbbaababa

# < a,b | babbbbaabbaa=a >
babbbbaabbaa -> a

# < a,b | babbbbaabbba=a >
babbbbaabbba -> a
babbbbaabba -> abbbbaabbba
babbbbaaba -> abbbbaabba
babbbbaaa -> abbbbaaba

# < a,b | babbbbabaaaa=a >
babbbbabaaaa -> a

# < a,b | babbbbabaaba=a >
babbbbabaaba -> a
babbbbabaaa -> abbbbabaaba

# < a,b | babbbbababaa=a >
babbbbababaa -> a

# < a,b | babbbbababba=a >
babbbbababba -> a
babbbbababa -> abbbbababba
babbbbabaa -> abbbbababa

# < a,b | babbbbabbaaa=a >
babbbbabbaaa -> a

# < a,b | babbbbabbaba=a >
babbbbabbaba -> a
babbbbabbaa -> abbbbabbaba

# < a,b | babbbbabbbaa=a >
babbbbabbbaa -> a

# < a,b | babbbbabbbba=a >
babbbbabbbba -> a
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | babbbbbaaaaa=a >
babbbbbaaaaa -> a

# < a,b | babbbbbaaaba=a >
babbbbbaaaba -> a
babbbbbaaaa -> abbbbbaaaba

# < a,b | babbbbbaabaa=a >
babbbbbaabaa -> a

# < a,b | babbbbbaabba=a >
babbbbbaabba -> a
babbbbbaaba -> abbbbbaabba
babbbbbaaa -> abbbbbaaba

# < a,b | babbbbbabaaa=a >
babbbbbabaaa -> a

# < a,b | babbbbbababa=a >
babbbbbababa -> a
babbbbbabaa -> abbbbbababa

# < a,b | babbbbbabbaa=a >
babbbbbabbaa -> a

# < a,b | babbbbbabbba=a >
babbbbbabbba -> a
babbbbbabba -> abbbbbabbba
babbbbbaba -> abbbbbabba
babbbbbaa -> abbbbbaba

# < a,b | babbbbbbaaaa=a >
babbbbbbaaaa -> a

# < a,b | babbbbbbaaba=a >
babbbbbbaaba -> a
babbbbbbaaa -> abbbbbbaaba

# < a,b | babbbbbbabaa=a >
babbbbbbabaa -> a

# < a,b | babbbbbbabba=a >
babbbbbbabba -> a
babbbbbbaba -> abbbbbbabba
babbbbbbaa -> abbbbbbaba

# < a,b | babbbbbbbaaa=a >
babbbbbbbaaa -> a

# < a,b | babbbbbbbaba=a >
babbbbbbbaba -> a
babbbbbbbaa -> abbbbbbbaba

# < a,b | babbbbbbbbaa=a >
babbbbbbbbaa -> a

# < a,b | babbbbbbbbba=a >
babbbbbbbbba -> a
babbbbbbbba -> abbbbbbbbba
babbbbbbba -> abbbbbbbba
babbbbbba -> abbbbbbba
babbbbba -> abbbbbba
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaaaaaa=a >
bbaaaaaaaaaa -> a

# < a,b | bbaaaaaaaaba=a >
bbaaaaaaaaba -> a

# < a,b | bbaaaaaaabaa=a >
bbaaaaaaabaa -> a

# < a,b | bbaaaaaaabba=a >
bbaaaaaaabba -> a
bbaaaaaaaa -> aaaaaaabba

# < a,b | bbaaaaaabaaa=a >
bbaaaaaabaaa -> a

# < a,b | bbaaaaaababa=a >
bbaaaaaababa -> a

# < a,b | bbaaaaaabbaa=a >
bbaaaaaabbaa -> a
bbaaaaaaa -> aaaaabbaa

# < a,b | bbaaaaaabbba=a >
bbaaaaaabbba -> a
bbaaaaaaba -> aaaaaabbba

# < a,b | bbaaaaabaaaa=a >
bbaaaaabaaaa -> a

# < a,b | bbaaaaabaaba=a >
bbaaaaabaaba -> a

# < a,b | bbaaaaababaa=a >
bbaaaaababaa -> a

# < a,b | bbaaaaababba=a >
bbaaaaababba -> a
bbaaaaabaa -> aaaaababba

# < a,b | bbaaaaabbaaa=a >
bbaaaaabbaaa -> a
bbaaaaaa -> aaabbaaa

# < a,b | bbaaaaabbaba=a >
bbaaaaabbaba -> a

# < a,b | bbaaaaabbbaa=a >
bbaaaaabbbaa -> a
bbaaaaaba -> aaaabbbaa

# < a,b | bbaaaaabbbba=a >
bbaaaaabbbba -> a
bbaaaaabba -> aaaaabbbba
bbaaaaaa -> aaaaabba

# < a,b | bbaaaabaaaaa=a >
bbaaaabaaaaa -> a

# < a,b | bbaaaabaaaba=a >
bbaaaabaaaba -> a

# < a,b | bbaaaabaabaa=a >
bbaaaabaabaa -> a

# < a,b | bbaaaabaabba=a >
bbaaaabaabba -> a
bbaaaabaaa -> aaaabaabba

# < a,b | bbaaaababaaa=a >
bbaaaababaaa -> a

# < a,b | bbaaaabababa=a >
bbaaaabababa -> a

# < a,b | bbaaaababbaa=a >
bbaaaababbaa -> a
bbaaaabaa -> aaababbaa

# < a,b | bbaaaababbba=a >
bbaaaababbba -> a
bbaaaababa -> aaaababbba

# < a,b | bbaaaabbaaaa=a >
bbaaaabbaaaa -> a
bbaaaaa -> abbaaaa

# < a,b | bbaaaabbaaba=a >
bbaaaabbaaba -> a

# < a,b | bbaaaabbabaa=a >
bbaaaabbabaa -> a

# < a,b | bbaaaabbbaaa=a >
bbaaaabbbaaa -> a
bbaaaaba -> aabbbaaa

# < a,b | bbaaaabbbaba=a >
bbaaaabbbaba -> a

# < a,b | bbaaaabbbbba=a >
bbaaaabbbbba -> a
bbaaaabbba -> aaaabbbbba
bbaaaaba -> aaaabbba

# < a,b | bbaaabaaaaaa=a >
bbaaabaaaaaa -> a

# < a,b | bbaaabaaaaba=a >
bbaaabaaaaba -> a

# < a,b | bbaaabaaabaa=a >
bbaaabaaabaa -> a

# < a,b | bbaaabaaabba=a >
bbaaabaaabba -> a
bbaaabaaaa -> aaabaaabba

# < a,b | bbaaabaabaaa=a >
bbaaabaabaaa -> a

# < a,b | bbaaabaababa=a >
bbaaabaababa -> a

# < a,b | bbaaabaabbaa=a >
bbaaabaabbaa -> a
bbaaabaaa -> aabaabbaa

# < a,b | bbaaabaabbba=a >
bbaaabaabbba -> a
bbaaabaaba -> aaabaabbba

# < a,b | bbaaababaaaa=a >
bbaaababaaaa -> a

# < a,b | bbaaababaaba=a >
bbaaababaaba -> a

# < a,b | bbaaabababaa=a >
bbaaabababaa -> a

# < a,b | bbaaabababba=a >
bbaaabababba -> a
bbaaababaa -> aaabababba

# < a,b | bbaaababbaaa=a >
bbaaababbaaa -> a
bbaaabaa -> ababbaaa

# < a,b | bbaaababbaba=a >
bbaaababbaba -> a

# < a,b | bbaaababbbaa=a >
bbaaababbbaa -> a
bbaaababa -> aababbbaa

# < a,b | bbaaababbbba=a >
bbaaababbbba -> a
bbaaababba -> aaababbbba
bbaaabaa -> aaababba

# < a,b | bbaaabbaaaaa=a >
bbaaabbaaaaa -> a

# < a,b | bbaaabbaaaba=a >
bbaaabbaaaba -> a

# < a,b | bbaaabbaabaa=a >
bbaaabbaabaa -> a

# < a,b | bbaaabbabaaa=a >
bbaaabbabaaa -> a

# < a,b | bbaaabbababa=a >
bbaaabbababa -> a

# < a,b | bbaaabbabbaa=a >
bbaaabbabbaa -> a
bbaaabbaa -> aabbabbaa
bbaaaa -> aabbaa

# < a,b | bbaaabbabbba=a >
bbaaabbabbba -> a
bbaaabbaba -> aaabbabbba

# < a,b | bbaaabbbaaaa=a >
bbaaabbbaaaa -> a

# < a,b | bbaaabbbaaba=a >
bbaaabbbaaba -> a

# < a,b | bbaaabbbabaa=a >
bbaaabbbabaa -> a

# < a,b | bbaaabbbbaba=a >
bbaaabbbbaba -> a

# < a,b | bbaaabbbbbba=a >
bbaaabbbbbba -> a
bbaaabbbba -> aaabbbbbba
bbaaabba -> aaabbbba
bbaaaa -> aaabba

# < a,b | bbaabaaaaaaa=a >
bbaabaaaaaaa -> a

# < a,b | bbaabaaaaaba=a >
bbaabaaaaaba -> a

# < a,b | bbaabaaaabaa=a >
bbaabaaaabaa -> a

# < a,b | bbaabaaaabba=a >
bbaabaaaabba -> a
bbaabaaaaa -> aabaaaabba

# < a,b | bbaabaaabaaa=a >
bbaabaaabaaa -> a

# < a,b | bbaabaaababa=a >
bbaabaaababa -> a

# < a,b | bbaabaaabbaa=a >
bbaabaaabbaa -> a
bbaabaaaa -> abaaabbaa

# < a,b | bbaabaaabbba=a >
bbaabaaabbba -> a
bbaabaaaba -> aabaaabbba

# < a,b | bbaabaabaaaa=a >
bbaabaabaaaa -> a

# < a,b | bbaabaabaaba=a >
bbaabaabaaba -> a

# < a,b | bbaabaababaa=a >
bbaabaababaa -> a

# < a,b | bbaabaababba=a >
bbaabaababba -> a
bbaabaabaa -> aabaababba

# < a,b | bbaabaabbaaa=a >
bbaabaabbaaa -> a

# < a,b | bbaabaabbaba=a >
bbaabaabbaba -> a

# < a,b | bbaabaabbbaa=a >
bbaabaabbbaa -> a
bbaabaaba -> abaabbbaa

# < a,b | bbaabaabbbba=a >
bbaabaabbbba -> a
bbaabaabba -> aabaabbbba
bbaabaaa -> aabaabba

# < a,b | bbaababaaaaa=a >
bbaababaaaaa -> a

# < a,b | bbaababaaaba=a >
bbaababaaaba -> a

# < a,b | bbaababaabaa=a >
bbaababaabaa -> a

# < a,b | bbaababaabba=a >
bbaababaabba -> a
bbaababaaa -> aababaabba

# < a,b | bbaabababaaa=a >
bbaabababaaa -> a

# < a,b | bbaababababa=a >
bbaababababa -> a

# < a,b | bbaabababbaa=a >
bbaabababbaa -> a
bbaababaa -> abababbaa

# < a,b | bbaabababbba=a >
bbaabababbba -> a
bbaabababa -> aabababbba

# < a,b | bbaababbaaaa=a >
bbaababbaaaa -> a

# < a,b | bbaababbaaba=a >
bbaababbaaba -> a
bbaabaa -> abbaaba

# < a,b | bbaababbabaa=a >
bbaababbabaa -> a

# < a,b | bbaababbbaaa=a >
bbaababbbaaa -> a

# < a,b | bbaababbbaba=a >
bbaababbbaba -> a

# < a,b | bbaababbbbba=a >
bbaababbbbba -> a
bbaababbba -> aababbbbba
bbaababa -> aababbba

# < a,b | bbaabbaaaaaa=a >
bbaabbaaaaaa -> a

# < a,b | bbaabbaaaaba=a >
bbaabbaaaaba -> a

# < a,b | bbaabbaaabaa=a >
bbaabbaaabaa -> a

# < a,b | bbaabbaaabba=a >
bbaabbaaabba -> a
bbaabbaaaa -> aabbaaabba

# < a,b | bbaabbaabaaa=a >
bbaabbaabaaa -> a

# < a,b | bbaabbaababa=a >
bbaabbaababa -> a

# < a,b | bbaabbaabbaa=a >
bbaabbaabbaa -> a
bbaaa -> abbaa

# < a,b | bbaabbaabbba=a >
bbaabbaabbba -> a
bbaabbaaba -> aabbaabbba

# < a,b | bbaabbabaaaa=a >
bbaabbabaaaa -> a

# < a,b | bbaabbabaaba=a >
bbaabbabaaba -> a

# < a,b | bbaabbababaa=a >
bbaabbababaa -> a

# < a,b | bbaabbababba=a >
bbaabbababba -> a
bbaabbabaa -> aabbababba

# < a,b | bbaabbabbaaa=a >
bbaabbabbaaa -> a

# < a,b | bbaabbabbaba=a >
bbaabbabbaba -> a

# < a,b | bbaabbabbbaa=a >
bbaabbabbbaa -> a
bbaabbaba -> abbabbbaa

# < a,b | bbaabbbaaaaa=a >
bbaabbbaaaaa -> a

# < a,b | bbaabbbaaaba=a >
bbaabbbaaaba -> a

# < a,b | bbaabbbaabaa=a >
bbaabbbaabaa -> a

# < a,b | bbaabbbaabba=a >
bbaabbbaabba -> a
bbaabbbaaa -> aabbbaabba

# < a,b | bbaabbbabaaa=a >
bbaabbbabaaa -> a

# < a,b | bbaabbbababa=a >
bbaabbbababa -> a

# < a,b | bbaabbbabbaa=a >
bbaabbbabbaa -> a
bbaabbbaa -> abbbabbaa
bbaaba -> abbbaa

# < a,b | bbaabbbabbba=a >
bbaabbbabbba -> a
bbaabbbaba -> aabbbabbba

# < a,b | bbaabbbbaaaa=a >
bbaabbbbaaaa -> a

# < a,b | bbaabbbbaaba=a >
bbaabbbbaaba -> a

# < a,b | bbaabbbbabaa=a >
bbaabbbbabaa -> a

# < a,b | bbaabbbbbaaa=a >
bbaabbbbbaaa -> a

# < a,b | bbaabbbbbaba=a >
bbaabbbbbaba -> a

# < a,b | bbaabbbbbbba=a >
bbaabbbbbbba -> a
bbaabbbbba -> aabbbbbbba
bbaabbba -> aabbbbba
bbaaba -> aabbba

# < a,b | bbabaaaaaaaa=a >
bbabaaaaaaaa -> a

# < a,b | bbabaaaaaaba=a >
bbabaaaaaaba -> a

# < a,b | bbabaaaaabaa=a >
bbabaaaaabaa -> a

# < a,b | bbabaaaaabba=a >
bbabaaaaabba -> a
bbabaaaaaa -> abaaaaabba

# < a,b | bbabaaaabaaa=a >
bbabaaaabaaa -> a

# < a,b | bbabaaaababa=a >
bbabaaaababa -> a

# < a,b | bbabaaaabbaa=a >
bbabaaaabbaa -> a

# < a,b | bbabaaaabbba=a >
bbabaaaabbba -> a
bbabaaaaba -> abaaaabbba

# < a,b | bbabaaabaaaa=a >
bbabaaabaaaa -> a

# < a,b | bbabaaabaaba=a >
bbabaaabaaba -> a

# < a,b | bbabaaababaa=a >
bbabaaababaa -> a

# < a,b | bbabaaababba=a >
bbabaaababba -> a
bbabaaabaa -> abaaababba

# < a,b | bbabaaabbaaa=a >
bbabaaabbaaa -> a

# < a,b | bbabaaabbaba=a >
bbabaaabbaba -> a
bbabaaaa -> aaabbaba

# < a,b | bbabaaabbbaa=a >
bbabaaabbbaa -> a

# < a,b | bbabaaabbbba=a >
bbabaaabbbba -> a
bbabaaabba -> abaaabbbba
bbabaaaa -> abaaabba

# < a,b | bbabaabaaaaa=a >
bbabaabaaaaa -> a

# < a,b | bbabaabaaaba=a >
bbabaabaaaba -> a

# < a,b | bbabaabaabaa=a >
bbabaabaabaa -> a

# < a,b | bbabaabaabba=a >
bbabaabaabba -> a
bbabaabaaa -> abaabaabba

# < a,b | bbabaababaaa=a >
bbabaababaaa -> a

# < a,b | bbabaabababa=a >
bbabaabababa -> a

# < a,b | bbabaababbaa=a >
bbabaababbaa -> a

# < a,b | bbabaababbba=a >
bbabaababbba -> a
bbabaababa -> abaababbba

# < a,b | bbabaabbaaaa=a >
bbabaabbaaaa -> a

# < a,b | bbabaabbaaba=a >
bbabaabbaaba -> a

# < a,b | bbabaabbabaa=a >
bbabaabbabaa -> a
bbabaaa -> abbabaa

# < a,b | bbabaabbabba=a >
bbabaabbabba -> a
bbabaabbaa -> abaabbabba

# < a,b | bbabaabbbaaa=a >
bbabaabbbaaa -> a

# < a,b | bbabaabbbaba=a >
bbabaabbbaba -> a
bbabaaba -> aabbbaba

# < a,b | bbabaabbbbaa=a >
bbabaabbbbaa -> a

# < a,b | bbabaabbbbba=a >
bbabaabbbbba -> a
bbabaabbba -> abaabbbbba
bbabaaba -> abaabbba

# < a,b | bbababaaaaaa=a >
bbababaaaaaa -> a

# < a,b | bbababaaaaba=a >
bbababaaaaba -> a

# < a,b | bbababaaabaa=a >
bbababaaabaa -> a

# < a,b | bbababaaabba=a >
bbababaaabba -> a
bbababaaaa -> ababaaabba

# < a,b | bbababaabaaa=a >
bbababaabaaa -> a

# < a,b | bbababaababa=a >
bbababaababa -> a

# < a,b | bbababaabbaa=a >
bbababaabbaa -> a

# < a,b | bbababaabbba=a >
bbababaabbba -> a
bbababaaba -> ababaabbba

# < a,b | bbabababaaaa=a >
bbabababaaaa -> a

# < a,b | bbabababaaba=a >
bbabababaaba -> a

# < a,b | bbababababaa=a >
bbababababaa -> a

# < a,b | bbababababba=a >
bbababababba -> a
bbabababaa -> ababababba

# < a,b | bbabababbaaa=a >
bbabababbaaa -> a

# < a,b | bbabababbaba=a >
bbabababbaba -> a
bbababaa -> ababbaba

# < a,b | bbabababbbaa=a >
bbabababbbaa -> a

# < a,b | bbabababbbba=a >
bbabababbbba -> a
bbabababba -> abababbbba
bbababaa -> abababba

# < a,b | bbababbaaaaa=a >
bbababbaaaaa -> a

# < a,b | bbababbaaaba=a >
bbababbaaaba -> a

# < a,b | bbababbaabaa=a >
bbababbaabaa -> a

# < a,b | bbababbaabba=a >
bbababbaabba -> a
bbababbaaa -> ababbaabba

# < a,b | bbababbabaaa=a >
bbababbabaaa -> a

# < a,b | bbababbababa=a >
bbababbababa -> a

# < a,b | bbababbabbaa=a >
bbababbabbaa -> a

# < a,b | bbababbbaaaa=a >
bbababbbaaaa -> a

# < a,b | bbababbbaaba=a >
bbababbbaaba -> a

# < a,b | bbababbbabaa=a >
bbababbbabaa -> a

# < a,b | bbababbbabba=a >
bbababbbabba -> a
bbababbbaa -> ababbbabba

# < a,b | bbababbbbaaa=a >
bbababbbbaaa -> a

# < a,b | bbababbbbbaa=a >
bbababbbbbaa -> a

# < a,b | bbababbbbbba=a >
bbababbbbbba -> a
bbababbbba -> ababbbbbba
bbababba -> ababbbba
bbabaa -> ababba

# < a,b | bbabbaaaaaaa=a >
bbabbaaaaaaa -> a

# < a,b | bbabbaaaaaba=a >
bbabbaaaaaba -> a

# < a,b | bbabbaaaabaa=a >
bbabbaaaabaa -> a

# < a,b | bbabbaaaabba=a >
bbabbaaaabba -> a
bbabbaaaaa -> abbaaaabba

# < a,b | bbabbaaabaaa=a >
bbabbaaabaaa -> a

# < a,b | bbabbaaababa=a >
bbabbaaababa -> a

# < a,b | bbabbaaabbaa=a >
bbabbaaabbaa -> a

# < a,b | bbabbaaabbba=a >
bbabbaaabbba -> a
bbabbaaaba -> abbaaabbba

# < a,b | bbabbaabaaaa=a >
bbabbaabaaaa -> a

# < a,b | bbabbaabaaba=a >
bbabbaabaaba -> a

# < a,b | bbabbaababaa=a >
bbabbaababaa -> a

# < a,b | bbabbaababba=a >
bbabbaababba -> a
bbabbaabaa -> abbaababba

# < a,b | bbabbaabbaaa=a >
bbabbaabbaaa -> a

# < a,b | bbabbaabbaba=a >
bbabbaabbaba -> a

# < a,b | bbabbaabbbaa=a >
bbabbaabbbaa -> a

# < a,b | bbabbaabbbba=a >
bbabbaabbbba -> a
bbabbaabba -> abbaabbbba
bbabbaaa -> abbaabba

# < a,b | bbabbabaaaaa=a >
bbabbabaaaaa -> a

# < a,b | bbabbabaaaba=a >
bbabbabaaaba -> a

# < a,b | bbabbabaabaa=a >
bbabbabaabaa -> a

# < a,b | bbabbabaabba=a >
bbabbabaabba -> a
bbabbabaaa -> abbabaabba

# < a,b | bbabbababaaa=a >
bbabbababaaa -> a

# < a,b | bbabbabababa=a >
bbabbabababa -> a

# < a,b | bbabbababbaa=a >
bbabbababbaa -> a

# < a,b | bbabbababbba=a >
bbabbababbba -> a
bbabbababa -> abbababbba

# < a,b | bbabbabbaaaa=a >
bbabbabbaaaa -> a

# < a,b | bbabbabbaaba=a >
bbabbabbaaba -> a

# < a,b | bbabbabbabaa=a >
bbabbabbabaa -> a

# < a,b | bbabbabbabba=a >
bbabbabbabba -> a
bbaa -> abba

# < a,b | bbabbabbbaaa=a >
bbabbabbbaaa -> a

# < a,b | bbabbabbbaba=a >
bbabbabbbaba -> a

# < a,b | bbabbabbbbaa=a >
bbabbabbbbaa -> a

# < a,b | bbabbabbbbba=a >
bbabbabbbbba -> a
bbabbabbba -> abbabbbbba
bbabbaba -> abbabbba

# < a,b | bbabbbaaaaaa=a >
bbabbbaaaaaa -> a

# < a,b | bbabbbaaaaba=a >
bbabbbaaaaba -> a

# < a,b | bbabbbaaabaa=a >
bbabbbaaabaa -> a

# < a,b | bbabbbaaabba=a >
bbabbbaaabba -> a
bbabbbaaaa -> abbbaaabba

# < a,b | bbabbbaabaaa=a >
bbabbbaabaaa -> a

# < a,b | bbabbbaababa=a >
bbabbbaababa -> a

# < a,b | bbabbbaabbaa=a >
bbabbbaabbaa -> a

# < a,b | bbabbbaabbba=a >
bbabbbaabbba -> a
bbabbbaaba -> abbbaabbba

# < a,b | bbabbbabaaaa=a >
bbabbbabaaaa -> a

# < a,b | bbabbbabaaba=a >
bbabbbabaaba -> a

# < a,b | bbabbbababaa=a >
bbabbbababaa -> a

# < a,b | bbabbbababba=a >
bbabbbababba -> a
bbabbbabaa -> abbbababba

# < a,b | bbabbbabbaaa=a >
bbabbbabbaaa -> a

# < a,b | bbabbbabbaba=a >
bbabbbabbaba -> a

# < a,b | bbabbbabbbaa=a >
bbabbbabbbaa -> a

# < a,b | bbabbbabbbba=a >
bbabbbabbbba -> a
bbabbbabba -> abbbabbbba
bbabbbaa -> abbbabba

# < a,b | bbabbbbaaaaa=a >
bbabbbbaaaaa -> a

# < a,b | bbabbbbaaaba=a >
bbabbbbaaaba -> a

# < a,b | bbabbbbaabaa=a >
bbabbbbaabaa -> a

# < a,b | bbabbbbaabba=a >
bbabbbbaabba -> a
bbabbbbaaa -> abbbbaabba

# < a,b | bbabbbbabaaa=a >
bbabbbbabaaa -> a

# < a,b | bbabbbbababa=a >
bbabbbbababa -> a

# < a,b | bbabbbbabbaa=a >
bbabbbbabbaa -> a

# < a,b | bbabbbbabbba=a >
bbabbbbabbba -> a
bbabbbbaba -> abbbbabbba

# < a,b | bbabbbbbaaaa=a >
bbabbbbbaaaa -> a

# < a,b | bbabbbbbaaba=a >
bbabbbbbaaba -> a

# < a,b | bbabbbbbabaa=a >
bbabbbbbabaa -> a

# < a,b | bbabbbbbabba=a >
bbabbbbbabba -> a
bbabbbbbaa -> abbbbbabba

# < a,b | bbabbbbbbaaa=a >
bbabbbbbbaaa -> a

# < a,b | bbabbbbbbaba=a >
bbabbbbbbaba -> a

# < a,b | bbabbbbbbbaa=a >
bbabbbbbbbaa -> a

# < a,b | bbabbbbbbbba=a >
bbabbbbbbbba -> a
bbabbbbbba -> abbbbbbbba
bbabbbba -> abbbbbba
bbabba -> abbbba
bbaa -> abba

# < a,b | bbbaaaaaaaaa=a >
bbbaaaaaaaaa -> a

# < a,b | bbbaaaaaaaba=a >
bbbaaaaaaaba -> a

# < a,b | bbbaaaaaabaa=a >
bbbaaaaaabaa -> a

# < a,b | bbbaaaaaabba=a >
bbbaaaaaabba -> a

# < a,b | bbbaaaaabaaa=a >
bbbaaaaabaaa -> a

# < a,b | bbbaaaaababa=a >
bbbaaaaababa -> a

# < a,b | bbbaaaaabbaa=a >
bbbaaaaabbaa -> a

# < a,b | bbbaaaaabbba=a >
bbbaaaaabbba -> a
bbbaaaaaa -> aaaaabbba

# < a,b | bbbaaaabaaaa=a >
bbbaaaabaaaa -> a

# < a,b | bbbaaaabaaba=a >
bbbaaaabaaba -> a

# < a,b | bbbaaaababaa=a >
bbbaaaababaa -> a

# < a,b | bbbaaaababba=a >
bbbaaaababba -> a

# < a,b | bbbaaaabbaaa=a >
bbbaaaabbaaa -> a

# < a,b | bbbaaaabbaba=a >
bbbaaaabbaba -> a

# < a,b | bbbaaaabbbaa=a >
bbbaaaabbbaa -> a
bbbaaaaa -> aaabbbaa

# < a,b | bbbaaaabbbba=a >
bbbaaaabbbba -> a
bbbaaaaba -> aaaabbbba

# < a,b | bbbaaabaaaaa=a >
bbbaaabaaaaa -> a

# < a,b | bbbaaabaaaba=a >
bbbaaabaaaba -> a

# < a,b | bbbaaabaabaa=a >
bbbaaabaabaa -> a

# < a,b | bbbaaabaabba=a >
bbbaaabaabba -> a

# < a,b | bbbaaababaaa=a >
bbbaaababaaa -> a

# < a,b | bbbaaabababa=a >
bbbaaabababa -> a

# < a,b | bbbaaababbaa=a >
bbbaaababbaa -> a

# < a,b | bbbaaababbba=a >
bbbaaababbba -> a
bbbaaabaa -> aaababbba

# < a,b | bbbaaabbaaaa=a >
bbbaaabbaaaa -> a

# < a,b | bbbaaabbaaba=a >
bbbaaabbaaba -> a

# < a,b | bbbaaabbabaa=a >
bbbaaabbabaa -> a

# < a,b | bbbaaabbabba=a >
bbbaaabbabba -> a

# < a,b | bbbaaabbbaaa=a >
bbbaaabbbaaa -> a
bbbaaaa -> abbbaaa

# < a,b | bbbaaabbbaba=a >
bbbaaabbbaba -> a

# < a,b | bbbaaabbbbaa=a >
bbbaaabbbbaa -> a
bbbaaaba -> aabbbbaa

# < a,b | bbbaaabbbbba=a >
bbbaaabbbbba -> a
bbbaaabba -> aaabbbbba

# < a,b | bbbaabaaaaaa=a >
bbbaabaaaaaa -> a

# < a,b | bbbaabaaaaba=a >
bbbaabaaaaba -> a

# < a,b | bbbaabaaabaa=a >
bbbaabaaabaa -> a

# < a,b | bbbaabaaabba=a >
bbbaabaaabba -> a

# < a,b | bbbaabaabaaa=a >
bbbaabaabaaa -> a

# < a,b | bbbaabaababa=a >
bbbaabaababa -> a

# < a,b | bbbaabaabbaa=a >
bbbaabaabbaa -> a

# < a,b | bbbaabaabbba=a >
bbbaabaabbba -> a
bbbaabaaa -> aabaabbba

# < a,b | bbbaababaaaa=a >
bbbaababaaaa -> a

# < a,b | bbbaababaaba=a >
bbbaababaaba -> a

# < a,b | bbbaabababaa=a >
bbbaabababaa -> a

# < a,b | bbbaabababba=a >
bbbaabababba -> a

# < a,b | bbbaababbaaa=a >
bbbaababbaaa -> a

# < a,b | bbbaababbaba=a >
bbbaababbaba -> a

# < a,b | bbbaababbbaa=a >
bbbaababbbaa -> a
bbbaabaa -> ababbbaa

# < a,b | bbbaababbbba=a >
bbbaababbbba -> a
bbbaababa -> aababbbba

# < a,b | bbbaabbaaaaa=a >
bbbaabbaaaaa -> a

# < a,b | bbbaabbaaaba=a >
bbbaabbaaaba -> a

# < a,b | bbbaabbaabaa=a >
bbbaabbaabaa -> a

# < a,b | bbbaabbaabba=a >
bbbaabbaabba -> a

# < a,b | bbbaabbabaaa=a >
bbbaabbabaaa -> a

# < a,b | bbbaabbababa=a >
bbbaabbababa -> a

# < a,b | bbbaabbabbaa=a >
bbbaabbabbaa -> a

# < a,b | bbbaabbabbba=a >
bbbaabbabbba -> a
bbbaabbaa -> aabbabbba

# < a,b | bbbaabbbaaaa=a >
bbbaabbbaaaa -> a

# < a,b | bbbaabbbaaba=a >
bbbaabbbaaba -> a

# < a,b | bbbaabbbabaa=a >
bbbaabbbabaa -> a

# < a,b | bbbaabbbabba=a >
bbbaabbbabba -> a

# < a,b | bbbaabbbbaaa=a >
bbbaabbbbaaa -> a

# < a,b | bbbaabbbbaba=a >
bbbaabbbbaba -> a

# < a,b | bbbaabbbbbaa=a >
bbbaabbbbbaa -> a
bbbaabba -> abbbbbaa

# < a,b | bbbaabbbbbba=a >
bbbaabbbbbba -> a
bbbaabbba -> aabbbbbba
bbbaaa -> aabbba

# < a,b | bbbabaaaaaaa=a >
bbbabaaaaaaa -> a

# < a,b | bbbabaaaaaba=a >
bbbabaaaaaba -> a

# < a,b | bbbabaaaabaa=a >
bbbabaaaabaa -> a

# < a,b | bbbabaaaabba=a >
bbbabaaaabba -> a

# < a,b | bbbabaaabaaa=a >
bbbabaaabaaa -> a

# < a,b | bbbabaaababa=a >
bbbabaaababa -> a

# < a,b | bbbabaaabbaa=a >
bbbabaaabbaa -> a

# < a,b | bbbabaaabbba=a >
bbbabaaabbba -> a
bbbabaaaa -> abaaabbba

# < a,b | bbbabaabaaaa=a >
bbbabaabaaaa -> a

# < a,b | bbbabaabaaba=a >
bbbabaabaaba -> a

# < a,b | bbbabaababaa=a >
bbbabaababaa -> a

# < a,b | bbbabaababba=a >
bbbabaababba -> a

# < a,b | bbbabaabbaaa=a >
bbbabaabbaaa -> a

# < a,b | bbbabaabbaba=a >
bbbabaabbaba -> a

# < a,b | bbbabaabbbaa=a >
bbbabaabbbaa -> a

# < a,b | bbbabaabbbba=a >
bbbabaabbbba -> a
bbbabaaba -> abaabbbba

# < a,b | bbbababaaaaa=a >
bbbababaaaaa -> a

# < a,b | bbbababaaaba=a >
bbbababaaaba -> a

# < a,b | bbbababaabaa=a >
bbbababaabaa -> a

# < a,b | bbbababaabba=a >
bbbababaabba -> a

# < a,b | bbbabababaaa=a >
bbbabababaaa -> a

# < a,b | bbbababababa=a >
bbbababababa -> a

# < a,b | bbbabababbaa=a >
bbbabababbaa -> a

# < a,b | bbbabababbba=a >
bbbabababbba -> a
bbbababaa -> abababbba

# < a,b | bbbababbaaaa=a >
bbbababbaaaa -> a

# < a,b | bbbababbaaba=a >
bbbababbaaba -> a

# < a,b | bbbababbabaa=a >
bbbababbabaa -> a

# < a,b | bbbababbabba=a >
bbbababbabba -> a

# < a,b | bbbababbbaaa=a >
bbbababbbaaa -> a

# < a,b | bbbababbbaba=a >
bbbababbbaba -> a
bbbabaa -> abbbaba

# < a,b | bbbababbbbaa=a >
bbbababbbbaa -> a

# < a,b | bbbababbbbba=a >
bbbababbbbba -> a
bbbababba -> ababbbbba

# < a,b | bbbabbaaaaaa=a >
bbbabbaaaaaa -> a

# < a,b | bbbabbaaaaba=a >
bbbabbaaaaba -> a

# < a,b | bbbabbaaabaa=a >
bbbabbaaabaa -> a

# < a,b | bbbabbaaabba=a >
bbbabbaaabba -> a

# < a,b | bbbabbaabaaa=a >
bbbabbaabaaa -> a

# < a,b | bbbabbaababa=a >
bbbabbaababa -> a

# < a,b | bbbabbaabbaa=a >
bbbabbaabbaa -> a

# < a,b | bbbabbaabbba=a >
bbbabbaabbba -> a
bbbabbaaa -> abbaabbba

# < a,b | bbbabbabaaaa=a >
bbbabbabaaaa -> a

# < a,b | bbbabbabaaba=a >
bbbabbabaaba -> a

# < a,b | bbbabbababaa=a >
bbbabbababaa -> a

# < a,b | bbbabbababba=a >
bbbabbababba -> a

# < a,b | bbbabbabbaaa=a >
bbbabbabbaaa -> a

# < a,b | bbbabbabbaba=a >
bbbabbabbaba -> a

# < a,b | bbbabbabbbaa=a >
bbbabbabbbaa -> a

# < a,b | bbbabbabbbba=a >
bbbabbabbbba -> a
bbbabbaba -> abbabbbba

# < a,b | bbbabbbaaaaa=a >
bbbabbbaaaaa -> a

# < a,b | bbbabbbaaaba=a >
bbbabbbaaaba -> a

# < a,b | bbbabbbaabaa=a >
bbbabbbaabaa -> a

# < a,b | bbbabbbaabba=a >
bbbabbbaabba -> a

# < a,b | bbbabbbabaaa=a >
bbbabbbabaaa -> a

# < a,b | bbbabbbababa=a >
bbbabbbababa -> a

# < a,b | bbbabbbabbaa=a >
bbbabbbabbaa -> a

# < a,b | bbbabbbabbba=a >
bbbabbbabbba -> a
bbbaa -> abbba

# < a,b | bbbabbbbaaaa=a >
bbbabbbbaaaa -> a

# < a,b | bbbabbbbaaba=a >
bbbabbbbaaba -> a

# < a,b | bbbabbbbabaa=a >
bbbabbbbabaa -> a

# < a,b | bbbabbbbabba=a >
bbbabbbbabba -> a

# < a,b | bbbabbbbbaaa=a >
bbbabbbbbaaa -> a

# < a,b | bbbabbbbbaba=a >
bbbabbbbbaba -> a

# < a,b | bbbabbbbbbaa=a >
bbbabbbbbbaa -> a

# < a,b | bbbabbbbbbba=a >
bbbabbbbbbba -> a
bbbabbbba -> abbbbbbba
bbbaba -> abbbba

# < a,b | bbbbaaaaaaaa=a >
bbbbaaaaaaaa -> a

# < a,b | bbbbaaaaaaba=a >
bbbbaaaaaaba -> a

# < a,b | bbbbaaaaabaa=a >
bbbbaaaaabaa -> a

# < a,b | bbbbaaaaabba=a >
bbbbaaaaabba -> a

# < a,b | bbbbaaaabaaa=a >
bbbbaaaabaaa -> a

# < a,b | bbbbaaaababa=a >
bbbbaaaababa -> a

# < a,b | bbbbaaaabbaa=a >
bbbbaaaabbaa -> a

# < a,b | bbbbaaaabbba=a >
bbbbaaaabbba -> a

# < a,b | bbbbaaabaaaa=a >
bbbbaaabaaaa -> a

# < a,b | bbbbaaabaaba=a >
bbbbaaabaaba -> a

# < a,b | bbbbaaababaa=a >
bbbbaaababaa -> a

# < a,b | bbbbaaababba=a >
bbbbaaababba -> a

# < a,b | bbbbaaabbaaa=a >
bbbbaaabbaaa -> a

# < a,b | bbbbaaabbaba=a >
bbbbaaabbaba -> a

# < a,b | bbbbaaabbbaa=a >
bbbbaaabbbaa -> a

# < a,b | bbbbaaabbbba=a >
bbbbaaabbbba -> a
bbbbaaaa -> aaabbbba

# < a,b | bbbbaabaaaaa=a >
bbbbaabaaaaa -> a

# < a,b | bbbbaabaaaba=a >
bbbbaabaaaba -> a

# < a,b | bbbbaabaabaa=a >
bbbbaabaabaa -> a

# < a,b | bbbbaabaabba=a >
bbbbaabaabba -> a

# < a,b | bbbbaababaaa=a >
bbbbaababaaa -> a

# < a,b | bbbbaabababa=a >
bbbbaabababa -> a

# < a,b | bbbbaababbaa=a >
bbbbaababbaa -> a

# < a,b | bbbbaababbba=a >
bbbbaababbba -> a

# < a,b | bbbbaabbaaaa=a >
bbbbaabbaaaa -> a

# < a,b | bbbbaabbaaba=a >
bbbbaabbaaba -> a

# < a,b | bbbbaabbabaa=a >
bbbbaabbabaa -> a

# < a,b | bbbbaabbabba=a >
bbbbaabbabba -> a

# < a,b | bbbbaabbbaaa=a >
bbbbaabbbaaa -> a

# < a,b | bbbbaabbbaba=a >
bbbbaabbbaba -> a

# < a,b | bbbbaabbbbaa=a >
bbbbaabbbbaa -> a
bbbbaaa -> abbbbaa

# < a,b | bbbbaabbbbba=a >
bbbbaabbbbba -> a
bbbbaaba -> aabbbbba

# < a,b | bbbbabaaaaaa=a >
bbbbabaaaaaa -> a

# < a,b | bbbbabaaaaba=a >
bbbbabaaaaba -> a

# < a,b | bbbbabaaabaa=a >
bbbbabaaabaa -> a

# < a,b | bbbbabaaabba=a >
bbbbabaaabba -> a

# < a,b | bbbbabaabaaa=a >
bbbbabaabaaa -> a

# < a,b | bbbbabaababa=a >
bbbbabaababa -> a

# < a,b | bbbbabaabbaa=a >
bbbbabaabbaa -> a

# < a,b | bbbbabaabbba=a >
bbbbabaabbba -> a

# < a,b | bbbbababaaaa=a >
bbbbababaaaa -> a

# < a,b | bbbbababaaba=a >
bbbbababaaba -> a

# < a,b | bbbbabababaa=a >
bbbbabababaa -> a

# < a,b | bbbbabababba=a >
bbbbabababba -> a

# < a,b | bbbbababbaaa=a >
bbbbababbaaa -> a

# < a,b | bbbbababbaba=a >
bbbbababbaba -> a

# < a,b | bbbbababbbaa=a >
bbbbababbbaa -> a

# < a,b | bbbbababbbba=a >
bbbbababbbba -> a
bbbbabaa -> ababbbba

# < a,b | bbbbabbaaaaa=a >
bbbbabbaaaaa -> a

# < a,b | bbbbabbaaaba=a >
bbbbabbaaaba -> a

# < a,b | bbbbabbaabaa=a >
bbbbabbaabaa -> a

# < a,b | bbbbabbaabba=a >
bbbbabbaabba -> a

# < a,b | bbbbabbabaaa=a >
bbbbabbabaaa -> a

# < a,b | bbbbabbababa=a >
bbbbabbababa -> a

# < a,b | bbbbabbabbaa=a >
bbbbabbabbaa -> a

# < a,b | bbbbabbabbba=a >
bbbbabbabbba -> a

# < a,b | bbbbabbbaaaa=a >
bbbbabbbaaaa -> a

# < a,b | bbbbabbbaaba=a >
bbbbabbbaaba -> a

# < a,b | bbbbabbbabaa=a >
bbbbabbbabaa -> a

# < a,b | bbbbabbbabba=a >
bbbbabbbabba -> a

# < a,b | bbbbabbbbaaa=a >
bbbbabbbbaaa -> a

# < a,b | bbbbabbbbaba=a >
bbbbabbbbaba -> a

# < a,b | bbbbabbbbbaa=a >
bbbbabbbbbaa -> a

# < a,b | bbbbabbbbbba=a >
bbbbabbbbbba -> a
bbbbabba -> abbbbbba

# < a,b | bbbbbaaaaaaa=a >
bbbbbaaaaaaa -> a

# < a,b | bbbbbaaaaaba=a >
bbbbbaaaaaba -> a

# < a,b | bbbbbaaaabaa=a >
bbbbbaaaabaa -> a

# < a,b | bbbbbaaaabba=a >
bbbbbaaaabba -> a

# < a,b | bbbbbaaabaaa=a >
bbbbbaaabaaa -> a

# < a,b | bbbbbaaababa=a >
bbbbbaaababa -> a

# < a,b | bbbbbaaabbaa=a >
bbbbbaaabbaa -> a

# < a,b | bbbbbaaabbba=a >
bbbbbaaabbba -> a

# < a,b | bbbbbaabaaaa=a >
bbbbbaabaaaa -> a

# < a,b | bbbbbaabaaba=a >
bbbbbaabaaba -> a

# < a,b | bbbbbaababaa=a >
bbbbbaababaa -> a

# < a,b | bbbbbaababba=a >
bbbbbaababba -> a

# < a,b | bbbbbaabbaaa=a >
bbbbbaabbaaa -> a

# < a,b | bbbbbaabbaba=a >
bbbbbaabbaba -> a

# < a,b | bbbbbaabbbaa=a >
bbbbbaabbbaa -> a

# < a,b | bbbbbaabbbba=a >
bbbbbaabbbba -> a

# < a,b | bbbbbabaaaaa=a >
bbbbbabaaaaa -> a

# < a,b | bbbbbabaaaba=a >
bbbbbabaaaba -> a

# < a,b | bbbbbabaabaa=a >
bbbbbabaabaa -> a

# < a,b | bbbbbabaabba=a >
bbbbbabaabba -> a

# < a,b | bbbbbababaaa=a >
bbbbbababaaa -> a

# < a,b | bbbbbabababa=a >
bbbbbabababa -> a

# < a,b | bbbbbababbaa=a >
bbbbbababbaa -> a

# < a,b | bbbbbababbba=a >
bbbbbababbba -> a

# < a,b | bbbbbabbaaaa=a >
bbbbbabbaaaa -> a

# < a,b | bbbbbabbaaba=a >
bbbbbabbaaba -> a

# < a,b | bbbbbabbabaa=a >
bbbbbabbabaa -> a

# < a,b | bbbbbabbabba=a >
bbbbbabbabba -> a

# < a,b | bbbbbabbbaaa=a >
bbbbbabbbaaa -> a

# < a,b | bbbbbabbbaba=a >
bbbbbabbbaba -> a

# < a,b | bbbbbabbbbaa=a >
bbbbbabbbbaa -> a

# < a,b | bbbbbabbbbba=a >
bbbbbabbbbba -> a
bbbbbaa -> abbbbba

# < a,b | bbbbbbaaaaaa=a >
bbbbbbaaaaaa -> a

# < a,b | bbbbbbaaaaba=a >
bbbbbbaaaaba -> a

# < a,b | bbbbbbaaabaa=a >
bbbbbbaaabaa -> a

# < a,b | bbbbbbaaabba=a >
bbbbbbaaabba -> a

# < a,b | bbbbbbaabaaa=a >
bbbbbbaabaaa -> a

# < a,b | bbbbbbaababa=a >
bbbbbbaababa -> a

# < a,b | bbbbbbaabbaa=a >
bbbbbbaabbaa -> a

# < a,b | bbbbbbaabbba=a >
bbbbbbaabbba -> a

# < a,b | bbbbbbabaaaa=a >
bbbbbbabaaaa -> a

# < a,b | bbbbbbabaaba=a >
bbbbbbabaaba -> a

# < a,b | bbbbbbababaa=a >
bbbbbbababaa -> a

# < a,b | bbbbbbababba=a >
bbbbbbababba -> a

# < a,b | bbbbbbabbaaa=a >
bbbbbbabbaaa -> a

# < a,b | bbbbbbabbaba=a >
bbbbbbabbaba -> a

# < a,b | bbbbbbabbbaa=a >
bbbbbbabbbaa -> a

# < a,b | bbbbbbabbbba=a >
bbbbbbabbbba -> a

# < a,b | bbbbbbbaaaaa=a >
bbbbbbbaaaaa -> a

# < a,b | bbbbbbbaaaba=a >
bbbbbbbaaaba -> a

# < a,b | bbbbbbbaabaa=a >
bbbbbbbaabaa -> a

# < a,b | bbbbbbbaabba=a >
bbbbbbbaabba -> a

# < a,b | bbbbbbbabaaa=a >
bbbbbbbabaaa -> a

# < a,b | bbbbbbbababa=a >
bbbbbbbababa -> a

# < a,b | bbbbbbbabbaa=a >
bbbbbbbabbaa -> a

# < a,b | bbbbbbbabbba=a >
bbbbbbbabbba -> a

# < a,b | bbbbbbbbaaaa=a >
bbbbbbbbaaaa -> a

# < a,b | bbbbbbbbaaba=a >
bbbbbbbbaaba -> a

# < a,b | bbbbbbbbabaa=a >
bbbbbbbbabaa -> a

# < a,b | bbbbbbbbabba=a >
bbbbbbbbabba -> a

# < a,b | bbbbbbbbbaaa=a >
bbbbbbbbbaaa -> a

# < a,b | bbbbbbbbbaba=a >
bbbbbbbbbaba -> a

# < a,b | bbbbbbbbbbaa=a >
bbbbbbbbbbaa -> a

# < a,b | bbbbbbbbbbba=a >
bbbbbbbbbbba -> a

# < a,b | baaaaaaaaaaaa=a >
baaaaaaaaaaaa -> a

# < a,b | baaaaaaaaaaba=a >
baaaaaaaaaaba -> a
baaaaaaaaaaa -> aaaaaaaaaaba

# < a,b | baaaaaaaaabaa=a >
baaaaaaaaabaa -> a
baaaaaaaaaa -> aaaaaaaabaa

# < a,b | baaaaaaaaabba=a >
baaaaaaaaabba -> a
baaaaaaaaaba -> aaaaaaaaabba
baaaaaaaaaa -> aaaaaaaaaba

# < a,b | baaaaaaaabaaa=a >
baaaaaaaabaaa -> a
baaaaaaaaa -> aaaaaabaaa

# < a,b | baaaaaaaabbba=a >
baaaaaaaabbba -> a
baaaaaaaabba -> aaaaaaaabbba
baaaaaaaaba -> aaaaaaaabba
baaaaaaaaa -> aaaaaaaaba

# < a,b | baaaaaaabaaaa=a >
baaaaaaabaaaa -> a
baaaaaaaa -> aaaabaaaa

# < a,b | baaaaaaababaa=a >
baaaaaaababaa -> a
baaaaaaabaa -> aaaaaababaa
baaaaaaaa -> aaaaaabaa

# < a,b | baaaaaaabbbba=a >
baaaaaaabbbba -> a
baaaaaaabbba -> aaaaaaabbbba
baaaaaaabba -> aaaaaaabbba
baaaaaaaba -> aaaaaaabba
baaaaaaaa -> aaaaaaaba

# < a,b | baaaaaabaaaaa=a >
baaaaaabaaaaa -> a
baaaaaaa -> aabaaaaa

# < a,b | baaaaaabbbbba=a >
baaaaaabbbbba -> a
baaaaaabbbba -> aaaaaabbbbba
baaaaaabbba -> aaaaaabbbba
baaaaaabba -> aaaaaabbba
baaaaaaba -> aaaaaabba
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaaaaaa=a >
baaaaabaaaaaa -> a

# < a,b | baaaaabaabaaa=a >
baaaaabaabaaa -> a
baaaaabaaa -> aaabaabaaa
baaaaaa -> aaabaaa

# < a,b | baaaaabababaa=a >
baaaaabababaa -> a
baaaaababaa -> aaaabababaa
baaaaabaa -> aaaababaa
baaaaaa -> aaaabaa

# < a,b | baaaaabbbbbba=a >
baaaaabbbbbba -> a
baaaaabbbbba -> aaaaabbbbbba
baaaaabbbba -> aaaaabbbbba
baaaaabbba -> aaaaabbbba
baaaaabba -> aaaaabbba
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaaaaaa=a >
baaaabaaaaaaa -> a

# < a,b | baaaabaaaaaba=a >
baaaabaaaaaba -> a
baaaabaaaaaa -> aaaabaaaaaba

# < a,b | baaaabaaaabaa=a >
baaaabaaaabaa -> a
baaaaa -> aaabaa

# < a,b | baaaababaaaaa=a >
baaaababaaaaa -> a

# < a,b | baaaabbaaaaaa=a >
baaaabbaaaaaa -> a

# < a,b | baaaabbaaaaba=a >
baaaabbaaaaba -> a
baaaabbaaaaa -> aaaabbaaaaba

# < a,b | baaaabbbaaaaa=a >
baaaabbbaaaaa -> a

# < a,b | baaaabbbbbbba=a >
baaaabbbbbbba -> a
baaaabbbbbba -> aaaabbbbbbba
baaaabbbbba -> aaaabbbbbba
baaaabbbba -> aaaabbbbba
baaaabbba -> aaaabbbba
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaaaaaa=a >
baaabaaaaaaaa -> a

# < a,b | baaabaaaaaaba=a >
baaabaaaaaaba -> a
baaabaaaaaaa -> aaabaaaaaaba

# < a,b | baaabaaaaabaa=a >
baaabaaaaabaa -> a
baaabaaaaaa -> aabaaaaabaa

# < a,b | baaabaaaaabba=a >
baaabaaaaabba -> a
baaabaaaaaba -> aaabaaaaabba
baaabaaaaaa -> aaabaaaaaba

# < a,b | baaabaaaabaaa=a >
baaabaaaabaaa -> a
baaabaaaaa -> abaaaabaaa

# < a,b | baaabaaaabbba=a >
baaabaaaabbba -> a
baaabaaaabba -> aaabaaaabbba
baaabaaaaba -> aaabaaaabba
baaabaaaaa -> aaabaaaaba

# < a,b | baaabaaabaaaa=a >
baaabaaabaaaa -> a

# < a,b | baaabaabaaaaa=a >
baaabaabaaaaa -> a

# < a,b | baaabaabbaaaa=a >
baaabaabbaaaa -> a

# < a,b | baaababaaaaaa=a >
baaababaaaaaa -> a

# < a,b | baaababaaaaba=a >
baaababaaaaba -> a
baaababaaaaa -> aaababaaaaba

# < a,b | baaababaaabaa=a >
baaababaaabaa -> a
baaababaaaa -> aababaaabaa

# < a,b | baaabababaaaa=a >
baaabababaaaa -> a

# < a,b | baaababababaa=a >
baaababababaa -> a
baaabababaa -> aababababaa
baaababaa -> aabababaa
baaabaa -> aababaa
baaaa -> aabaa

# < a,b | baaababbaaaaa=a >
baaababbaaaaa -> a

# < a,b | baaababbbaaaa=a >
baaababbbaaaa -> a

# < a,b | baaabbaaaaaaa=a >
baaabbaaaaaaa -> a

# < a,b | baaabbaaaaaba=a >
baaabbaaaaaba -> a
baaabbaaaaaa -> aaabbaaaaaba

# < a,b | baaabbaaaabaa=a >
baaabbaaaabaa -> a
baaabbaaaaa -> aabbaaaabaa

# < a,b | baaabbaaaabba=a >
baaabbaaaabba -> a
baaabbaaaaba -> aaabbaaaabba
baaabbaaaaa -> aaabbaaaaba

# < a,b | baaabbaaabaaa=a >
baaabbaaabaaa -> a
baaabbaaaa -> abbaaabaaa

# < a,b | baaabbaabaaaa=a >
baaabbaabaaaa -> a

# < a,b | baaabbabaaaaa=a >
baaabbabaaaaa -> a

# < a,b | baaabbabaaaba=a >
baaabbabaaaba -> a
baaabbabaaaa -> aaabbabaaaba

# < a,b | baaabbabbaaaa=a >
baaabbabbaaaa -> a

# < a,b | baaabbbaaaaaa=a >
baaabbbaaaaaa -> a

# < a,b | baaabbbaaaaba=a >
baaabbbaaaaba -> a
baaabbbaaaaa -> aaabbbaaaaba

# < a,b | baaabbbaaabaa=a >
baaabbbaaabaa -> a
baaabbbaaaa -> aabbbaaabaa

# < a,b | baaabbbaaabba=a >
baaabbbaaabba -> a
baaabbbaaaba -> aaabbbaaabba
baaabbbaaaa -> aaabbbaaaba

# < a,b | baaabbbabaaaa=a >
baaabbbabaaaa -> a

# < a,b | baaabbbbaaaaa=a >
baaabbbbaaaaa -> a

# < a,b | baaabbbbaaaba=a >
baaabbbbaaaba -> a
baaabbbbaaaa -> aaabbbbaaaba

# < a,b | baaabbbbbaaaa=a >
baaabbbbbaaaa -> a

# < a,b | baaabbbbbbbba=a >
baaabbbbbbbba -> a
baaabbbbbbba -> aaabbbbbbbba
baaabbbbbba -> aaabbbbbbba
baaabbbbba -> aaabbbbbba
baaabbbba -> aaabbbbba
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaaaaaa=a >
baabaaaaaaaaa -> a

# < a,b | baabaaaaaaaba=a >
baabaaaaaaaba -> a
baabaaaaaaaa -> aabaaaaaaaba

# < a,b | baabaaaaaabaa=a >
baabaaaaaabaa -> a
baabaaaaaaa -> abaaaaaabaa

# < a,b | baabaaaaaabba=a >
baabaaaaaabba -> a
baabaaaaaaba -> aabaaaaaabba
baabaaaaaaa -> aabaaaaaaba

# < a,b | baabaaaaabaaa=a >
baabaaaaabaaa -> a

# < a,b | baabaaaaabbba=a >
baabaaaaabbba -> a
baabaaaaabba -> aabaaaaabbba
baabaaaaaba -> aabaaaaabba
baabaaaaaa -> aabaaaaaba

# < a,b | baabaaaabaaaa=a >
baabaaaabaaaa -> a

# < a,b | baabaaaabaaba=a >
baabaaaabaaba -> a
baabaaaabaaa -> aabaaaabaaba
baabaaaaa -> aaaabaaba

# < a,b | baabaaaababaa=a >
baabaaaababaa -> a
baabaaaabaa -> abaaaababaa
baabaaaaa -> abaaaabaa

# < a,b | baabaaaabbaaa=a >
baabaaaabbaaa -> a

# < a,b | baabaaaabbbba=a >
baabaaaabbbba -> a
baabaaaabbba -> aabaaaabbbba
baabaaaabba -> aabaaaabbba
baabaaaaba -> aabaaaabba
baabaaaaa -> aabaaaaba

# < a,b | baabaaabaaaaa=a >
baabaaabaaaaa -> a

# < a,b | baabaaabaaaba=a >
baabaaabaaaba -> a
baabaaabaaaa -> aabaaabaaaba

# < a,b | baabaaabaabaa=a >
baabaaabaabaa -> a
baabaaabaaa -> abaaabaabaa
baabaaaa -> aabaabaa

# < a,b | baabaaababaaa=a >
baabaaababaaa -> a

# < a,b | baabaaabbaaaa=a >
baabaaabbaaaa -> a

# < a,b | baabaaabbaaba=a >
baabaaabbaaba -> a
baabaaabbaaa -> aabaaabbaaba
baabaaaba -> aaabbaaba
baabaaaa -> aaabbaaa

# < a,b | baabaaabbbaaa=a >
baabaaabbbaaa -> a

# < a,b | baabaaabbbbba=a >
baabaaabbbbba -> a
baabaaabbbba -> aabaaabbbbba
baabaaabbba -> aabaaabbbba
baabaaabba -> aabaaabbba
baabaaaba -> aabaaabba
baabaaaa -> aabaaaba

# < a,b | baabaabaaaaaa=a >
baabaabaaaaaa -> a

# < a,b | baabaabaaaaba=a >
baabaabaaaaba -> a
baabaabaaaaa -> aabaabaaaaba

# < a,b | baabaabaaabaa=a >
baabaabaaabaa -> a
baabaabaaaa -> abaabaaabaa

# < a,b | baabaabaaabba=a >
baabaabaaabba -> a
baabaabaaaba -> aabaabaaabba
baabaabaaaa -> aabaabaaaba

# < a,b | baabaabaabaaa=a >
baabaabaabaaa -> a

# < a,b | baabaababaaaa=a >
baabaababaaaa -> a

# < a,b | baabaababbaaa=a >
baabaababbaaa -> a

# < a,b | baabaabbaaaaa=a >
baabaabbaaaaa -> a

# < a,b | baabaabbaaaba=a >
baabaabbaaaba -> a
baabaabbaaaa -> aabaabbaaaba

# < a,b | baabaabbabaaa=a >
baabaabbabaaa -> a

# < a,b | baabaabbbaaaa=a >
baabaabbbaaaa -> a

# < a,b | baabaabbbbaaa=a >
baabaabbbbaaa -> a

# < a,b | baababaaaaaaa=a >
baababaaaaaaa -> a

# < a,b | baababaaaaaba=a >
baababaaaaaba -> a
baababaaaaaa -> aababaaaaaba

# < a,b | baababaaaabaa=a >
baababaaaabaa -> a
baababaaaaa -> ababaaaabaa

# < a,b | baababaaaabba=a >
baababaaaabba -> a
baababaaaaba -> aababaaaabba
baababaaaaa -> aababaaaaba

# < a,b | baababaaabaaa=a >
baababaaabaaa -> a

# < a,b | baababaaabbba=a >
baababaaabbba -> a
baababaaabba -> aababaaabbba
baababaaaba -> aababaaabba
baababaaaa -> aababaaaba

# < a,b | baababaabaaaa=a >
baababaabaaaa -> a

# < a,b | baababaabaaba=a >
baababaabaaba -> a
baababaabaaa -> aababaabaaba
baababaaa -> abaabaaba

# < a,b | baababaababaa=a >
baababaababaa -> a
baabaa -> ababaa
baaa -> abaa

# < a,b | baababaabbaaa=a >
baababaabbaaa -> a

# < a,b | baabababaaaaa=a >
baabababaaaaa -> a

# < a,b | baabababaaaba=a >
baabababaaaba -> a
baabababaaaa -> aabababaaaba

# < a,b | baabababaabaa=a >
baabababaabaa -> a
baabababaaa -> abababaabaa

# < a,b | baababababaaa=a >
baababababaaa -> a

# < a,b | baabababbaaaa=a >
baabababbaaaa -> a

# < a,b | baabababbbaaa=a >
baabababbbaaa -> a

# < a,b | baababbaaaaaa=a >
baababbaaaaaa -> a

# < a,b | baababbaaaaba=a >
baababbaaaaba -> a
baababbaaaaa -> aababbaaaaba

# < a,b | baababbaaabaa=a >
baababbaaabaa -> a
baababbaaaa -> ababbaaabaa

# < a,b | baababbaaabba=a >
baababbaaabba -> a
baababbaaaba -> aababbaaabba
baababbaaaa -> aababbaaaba

# < a,b | baababbaabaaa=a >
baababbaabaaa -> a

# < a,b | baababbabaaaa=a >
baababbabaaaa -> a

# < a,b | baababbabbaaa=a >
baababbabbaaa -> a

# < a,b | baababbbaaaaa=a >
baababbbaaaaa -> a

# < a,b | baababbbaaaba=a >
baababbbaaaba -> a
baababbbaaaa -> aababbbaaaba

# < a,b | baababbbaabaa=a >
baababbbaabaa -> a
baababbbaaa -> ababbbaabaa

# < a,b | baababbbabaaa=a >
baababbbabaaa -> a

# < a,b | baababbbbaaaa=a >
baababbbbaaaa -> a

# < a,b | baababbbbbaaa=a >
baababbbbbaaa -> a

# < a,b | baabbaaaaaaaa=a >
baabbaaaaaaaa -> a

# < a,b | baabbaaaaaaba=a >
baabbaaaaaaba -> a
baabbaaaaaaa -> aabbaaaaaaba

# < a,b | baabbaaaaabaa=a >
baabbaaaaabaa -> a
baabbaaaaaa -> abbaaaaabaa

# < a,b | baabbaaaaabba=a >
baabbaaaaabba -> a
baabbaaaaaba -> aabbaaaaabba
baabbaaaaaa -> aabbaaaaaba

# < a,b | baabbaaaabaaa=a >
baabbaaaabaaa -> a

# < a,b | baabbaaaabbba=a >
baabbaaaabbba -> a
baabbaaaabba -> aabbaaaabbba
baabbaaaaba -> aabbaaaabba
baabbaaaaa -> aabbaaaaba

# < a,b | baabbaaabaaaa=a >
baabbaaabaaaa -> a

# < a,b | baabbaaabaaba=a >
baabbaaabaaba -> a
baabbaaabaaa -> aabbaaabaaba

# < a,b | baabbaaababaa=a >
baabbaaababaa -> a
baabbaaabaa -> abbaaababaa
baabbaaaa -> abbaaabaa

# < a,b | baabbaaabbaaa=a >
baabbaaabbaaa -> a

# < a,b | baabbaaabbbba=a >
baabbaaabbbba -> a
baabbaaabbba -> aabbaaabbbba
baabbaaabba -> aabbaaabbba
baabbaaaba -> aabbaaabba
baabbaaaa -> aabbaaaba

# < a,b | baabbaabaaaaa=a >
baabbaabaaaaa -> a

# < a,b | baabbaabaaaba=a >
baabbaabaaaba -> a
baabbaabaaaa -> aabbaabaaaba

# < a,b | baabbaabaabaa=a >
baabbaabaabaa -> a
baabbaabaaa -> abbaabaabaa

# < a,b | baabbaabaabba=a >
baabbaabaabba -> a
baabbaabaaba -> aabbaabaabba
baabbaaa -> aabaabba
baabbaabaaa -> aabbaabaaba

# < a,b | baabbaababaaa=a >
baabbaababaaa -> a

# < a,b | baabbaabbaaaa=a >
baabbaabbaaaa -> a

# < a,b | baabbaabbaaba=a >
baabbaabbaaba -> a
baabbaabbaaa -> aabbaabbaaba

# < a,b | baabbaabbbaaa=a >
baabbaabbbaaa -> a

# < a,b | baabbabaaaaaa=a >
baabbabaaaaaa -> a

# < a,b | baabbabaaaaba=a >
baabbabaaaaba -> a
baabbabaaaaa -> aabbabaaaaba

# < a,b | baabbabaaabaa=a >
baabbabaaabaa -> a
baabbabaaaa -> abbabaaabaa

# < a,b | baabbabaaabba=a >
baabbabaaabba -> a
baabbabaaaba -> aabbabaaabba
baabbabaaaa -> aabbabaaaba

# < a,b | baabbabaabaaa=a >
baabbabaabaaa -> a

# < a,b | baabbababaaaa=a >
baabbababaaaa -> a

# < a,b | baabbababaaba=a >
baabbababaaba -> a
baabbababaaa -> aabbababaaba

# < a,b | baabbababbaaa=a >
baabbababbaaa -> a

# < a,b | baabbabbaaaaa=a >
baabbabbaaaaa -> a

# < a,b | baabbabbaaaba=a >
baabbabbaaaba -> a
baabbabbaaaa -> aabbabbaaaba

# < a,b | baabbabbaabaa=a >
baabbabbaabaa -> a
baabbabbaaa -> abbabbaabaa

# < a,b | baabbabbabaaa=a >
baabbabbabaaa -> a

# < a,b | baabbabbbaaaa=a >
baabbabbbaaaa -> a

# < a,b | baabbabbbaaba=a >
baabbabbbaaba -> a
baabbabbbaaa -> aabbabbbaaba

# < a,b | baabbabbbbaaa=a >
baabbabbbbaaa -> a

# < a,b | baabbbaaaaaaa=a >
baabbbaaaaaaa -> a

# < a,b | baabbbaaaaaba=a >
baabbbaaaaaba -> a
baabbbaaaaaa -> aabbbaaaaaba

# < a,b | baabbbaaaabaa=a >
baabbbaaaabaa -> a
baabbbaaaaa -> abbbaaaabaa

# < a,b | baabbbaaaabba=a >
baabbbaaaabba -> a
baabbbaaaaba -> aabbbaaaabba
baabbbaaaaa -> aabbbaaaaba

# < a,b | baabbbaaabaaa=a >
baabbbaaabaaa -> a

# < a,b | baabbbaaabbba=a >
baabbbaaabbba -> a
baabbbaaabba -> aabbbaaabbba
baabbbaaaba -> aabbbaaabba
baabbbaaaa -> aabbbaaaba

# < a,b | baabbbaabaaaa=a >
baabbbaabaaaa -> a

# < a,b | baabbbaabaaba=a >
baabbbaabaaba -> a
baabbbaabaaa -> aabbbaabaaba

# < a,b | baabbbaababaa=a >
baabbbaababaa -> a
baabbbaabaa -> abbbaababaa
baabbbaaa -> abbbaabaa

# < a,b | baabbbaabbaaa=a >
baabbbaabbaaa -> a

# < a,b | baabbbabaaaaa=a >
baabbbabaaaaa -> a

# < a,b | baabbbabaaaba=a >
baabbbabaaaba -> a
baabbbabaaaa -> aabbbabaaaba

# < a,b | baabbbabaabaa=a >
baabbbabaabaa -> a
baabbbabaaa -> abbbabaabaa

# < a,b | baabbbabaabba=a >
baabbbabaabba -> a
baabbbabaaba -> aabbbabaabba
baabbbabaaa -> aabbbabaaba

# < a,b | baabbbababaaa=a >
baabbbababaaa -> a

# < a,b | baabbbabbaaaa=a >
baabbbabbaaaa -> a

# < a,b | baabbbabbaaba=a >
baabbbabbaaba -> a
baabbbabbaaa -> aabbbabbaaba

# < a,b | baabbbabbbaaa=a >
baabbbabbbaaa -> a

# < a,b | baabbbbaaaaaa=a >
baabbbbaaaaaa -> a

# < a,b | baabbbbaaaaba=a >
baabbbbaaaaba -> a
baabbbbaaaaa -> aabbbbaaaaba

# < a,b | baabbbbaaabaa=a >
baabbbbaaabaa -> a
baabbbbaaaa -> abbbbaaabaa

# < a,b | baabbbbaaabba=a >
baabbbbaaabba -> a
baabbbbaaaba -> aabbbbaaabba
baabbbbaaaa -> aabbbbaaaba

# < a,b | baabbbbaabaaa=a >
baabbbbaabaaa -> a

# < a,b | baabbbbaabbba=a >
baabbbbaabbba -> a
baabbbbaabba -> aabbbbaabbba
baabbbbaaba -> aabbbbaabba
baabbbbaaa -> aabbbbaaba

# < a,b | baabbbbabaaaa=a >
baabbbbabaaaa -> a

# < a,b | baabbbbabaaba=a >
baabbbbabaaba -> a
baabbbbabaaa -> aabbbbabaaba

# < a,b | baabbbbabbaaa=a >
baabbbbabbaaa -> a

# < a,b | baabbbbbaaaaa=a >
baabbbbbaaaaa -> a

# < a,b | baabbbbbaaaba=a >
baabbbbbaaaba -> a
baabbbbbaaaa -> aabbbbbaaaba

# < a,b | baabbbbbaabaa=a >
baabbbbbaabaa -> a
baabbbbbaaa -> abbbbbaabaa

# < a,b | baabbbbbaabba=a >
baabbbbbaabba -> a
baabbbbbaaba -> aabbbbbaabba
baabbbbbaaa -> aabbbbbaaba

# < a,b | baabbbbbabaaa=a >
baabbbbbabaaa -> a

# < a,b | baabbbbbbaaaa=a >
baabbbbbbaaaa -> a

# < a,b | baabbbbbbaaba=a >
baabbbbbbaaba -> a
baabbbbbbaaa -> aabbbbbbaaba

# < a,b | baabbbbbbbaaa=a >
baabbbbbbbaaa -> a

# < a,b | baabbbbbbbbba=a >
baabbbbbbbbba -> a
baabbbbbbbba -> aabbbbbbbbba
baabbbbbbba -> aabbbbbbbba
baabbbbbba -> aabbbbbbba
baabbbbba -> aabbbbbba
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaaaaaa=a >
babaaaaaaaaaa -> a

# < a,b | babaaaaaaaaba=a >
babaaaaaaaaba -> a
babaaaaaaaaa -> abaaaaaaaaba

# < a,b | babaaaaaaabaa=a >
babaaaaaaabaa -> a

# < a,b | babaaaaaaabba=a >
babaaaaaaabba -> a
babaaaaaaaba -> abaaaaaaabba
babaaaaaaaa -> abaaaaaaaba

# < a,b | babaaaaaabaaa=a >
babaaaaaabaaa -> a

# < a,b | babaaaaaababa=a >
babaaaaaababa -> a
babaaaaaabaa -> abaaaaaababa
babaaaaaaa -> aaaaaababa

# < a,b | babaaaaaabbaa=a >
babaaaaaabbaa -> a

# < a,b | babaaaaaabbba=a >
babaaaaaabbba -> a
babaaaaaabba -> abaaaaaabbba
babaaaaaaba -> abaaaaaabba
babaaaaaaa -> abaaaaaaba

# < a,b | babaaaaabaaaa=a >
babaaaaabaaaa -> a

# < a,b | babaaaaabaaba=a >
babaaaaabaaba -> a
babaaaaabaaa -> abaaaaabaaba

# < a,b | babaaaaababaa=a >
babaaaaababaa -> a
babaaaaaa -> aaaababaa

# < a,b | babaaaaabbaaa=a >
babaaaaabbaaa -> a

# < a,b | babaaaaabbaba=a >
babaaaaabbaba -> a
babaaaaabbaa -> abaaaaabbaba
babaaaaaba -> aaaaabbaba
babaaaaaa -> aaaaabbaa

# < a,b | babaaaaabbbaa=a >
babaaaaabbbaa -> a

# < a,b | babaaaaabbbba=a >
babaaaaabbbba -> a
babaaaaabbba -> abaaaaabbbba
babaaaaabba -> abaaaaabbba
babaaaaaba -> abaaaaabba
babaaaaaa -> abaaaaaba

# < a,b | babaaaabaaaaa=a >
babaaaabaaaaa -> a

# < a,b | babaaaabaaaba=a >
babaaaabaaaba -> a
babaaaabaaaa -> abaaaabaaaba

# < a,b | babaaaabaabaa=a >
babaaaabaabaa -> a

# < a,b | babaaaabaabba=a >
babaaaabaabba -> a
babaaaabaaba -> abaaaabaabba
babaaaabaaa -> abaaaabaaba

# < a,b | babaaaababaaa=a >
babaaaababaaa -> a
babaaaaa -> aababaaa

# < a,b | babaaaababbaa=a >
babaaaababbaa -> a

# < a,b | babaaaabbaaaa=a >
babaaaabbaaaa -> a

# < a,b | babaaaabbaaba=a >
babaaaabbaaba -> a
babaaaabbaaa -> abaaaabbaaba

# < a,b | babaaaabbbaaa=a >
babaaaabbbaaa -> a

# < a,b | babaaaabbbbaa=a >
babaaaabbbbaa -> a

# < a,b | babaaaabbbbba=a >
babaaaabbbbba -> a
babaaaabbbba -> abaaaabbbbba
babaaaabbba -> abaaaabbbba
babaaaabba -> abaaaabbba
babaaaaba -> abaaaabba
babaaaaa -> abaaaaba

# < a,b | babaaabaaaaaa=a >
babaaabaaaaaa -> a

# < a,b | babaaabaaaaba=a >
babaaabaaaaba -> a
babaaabaaaaa -> abaaabaaaaba

# < a,b | babaaabaaabaa=a >
babaaabaaabaa -> a

# < a,b | babaaabaaabba=a >
babaaabaaabba -> a
babaaabaaaba -> abaaabaaabba
babaaabaaaa -> abaaabaaaba

# < a,b | babaaabaabaaa=a >
babaaabaabaaa -> a

# < a,b | babaaabaababa=a >
babaaabaababa -> a
babaaabaabaa -> abaaabaababa
babaaabaaa -> aaabaababa

# < a,b | babaaabaabbaa=a >
babaaabaabbaa -> a

# < a,b | babaaabaabbba=a >
babaaabaabbba -> a
babaaabaabba -> abaaabaabbba
babaaabaaba -> abaaabaabba
babaaabaaa -> abaaabaaba

# < a,b | babaaababaaaa=a >
babaaababaaaa -> a

# < a,b | babaaabababaa=a >
babaaabababaa -> a
babaaabaa -> aabababaa

# < a,b | babaaababbaaa=a >
babaaababbaaa -> a

# < a,b | babaaababbaba=a >
babaaababbaba -> a
babaaababbaa -> abaaababbaba
babaaababa -> aaababbaba
babaaabaa -> aaababbaa
babaaaa -> aaababa

# < a,b | babaaababbbaa=a >
babaaababbbaa -> a

# < a,b | babaaabbaaaaa=a >
babaaabbaaaaa -> a

# < a,b | babaaabbaaaba=a >
babaaabbaaaba -> a
babaaabbaaaa -> abaaabbaaaba

# < a,b | babaaabbaabaa=a >
babaaabbaabaa -> a

# < a,b | babaaabbaabba=a >
babaaabbaabba -> a
babaaabbaaba -> abaaabbaabba
babaaabbaaa -> abaaabbaaba

# < a,b | babaaabbabbaa=a >
babaaabbabbaa -> a

# < a,b | babaaabbbaaaa=a >
babaaabbbaaaa -> a

# < a,b | babaaabbbaaba=a >
babaaabbbaaba -> a
babaaabbbaaa -> abaaabbbaaba

# < a,b | babaaabbbbaaa=a >
babaaabbbbaaa -> a

# < a,b | babaaabbbbbaa=a >
babaaabbbbbaa -> a

# < a,b | babaaabbbbbba=a >
babaaabbbbbba -> a
babaaabbbbba -> abaaabbbbbba
babaaabbbba -> abaaabbbbba
babaaabbba -> abaaabbbba
babaaabba -> abaaabbba
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaaaaaa=a >
babaabaaaaaaa -> a

# < a,b | babaabaaaaaba=a >
babaabaaaaaba -> a
babaabaaaaaa -> abaabaaaaaba

# < a,b | babaabaaaabaa=a >
babaabaaaabaa -> a

# < a,b | babaabaaaabba=a >
babaabaaaabba -> a
babaabaaaaba -> abaabaaaabba
babaabaaaaa -> abaabaaaaba

# < a,b | babaabaaabaaa=a >
babaabaaabaaa -> a

# < a,b | babaabaaababa=a >
babaabaaababa -> a
babaabaaabaa -> abaabaaababa
babaabaaaa -> aabaaababa

# < a,b | babaabaaabbaa=a >
babaabaaabbaa -> a

# < a,b | babaabaaabbba=a >
babaabaaabbba -> a
babaabaaabba -> abaabaaabbba
babaabaaaba -> abaabaaabba
babaabaaaa -> abaabaaaba

# < a,b | babaabaabaaaa=a >
babaabaabaaaa -> a

# < a,b | babaabaabaaba=a >
babaabaabaaba -> a
babaabaabaaa -> abaabaabaaba

# < a,b | babaabaababaa=a >
babaabaababaa -> a
babaabaaa -> abaababaa

# < a,b | babaabaabbaaa=a >
babaabaabbaaa -> a

# < a,b | babaabaabbaba=a >
babaabaabbaba -> a
babaabaabbaa -> abaabaabbaba
babaabaaba -> aabaabbaba
babaabaaa -> aabaabbaa

# < a,b | babaabaabbbaa=a >
babaabaabbbaa -> a

# < a,b | babaabaabbbba=a >
babaabaabbbba -> a
babaabaabbba -> abaabaabbbba
babaabaabba -> abaabaabbba
babaabaaba -> abaabaabba
babaabaaa -> abaabaaba

# < a,b | babaababaaaaa=a >
babaababaaaaa -> a

# < a,b | babaababaaaba=a >
babaababaaaba -> a
babaababaaaa -> abaababaaaba

# < a,b | babaababaabaa=a >
babaababaabaa -> a

# < a,b | babaabababaaa=a >
babaabababaaa -> a

# < a,b | babaabababbaa=a >
babaabababbaa -> a

# < a,b | babaababbaaaa=a >
babaababbaaaa -> a

# < a,b | babaababbaaba=a >
babaababbaaba -> a
babaababbaaa -> abaababbaaba

# < a,b | babaababbbaaa=a >
babaababbbaaa -> a

# < a,b | babaababbbbaa=a >
babaababbbbaa -> a

# < a,b | babaabbaaaaaa=a >
babaabbaaaaaa -> a

# < a,b | babaabbaaaaba=a >
babaabbaaaaba -> a
babaabbaaaaa -> abaabbaaaaba

# < a,b | babaabbaaabaa=a >
babaabbaaabaa -> a

# < a,b | babaabbaaabba=a >
babaabbaaabba -> a
babaabbaaaba -> abaabbaaabba
babaabbaaaa -> abaabbaaaba

# < a,b | babaabbaabaaa=a >
babaabbaabaaa -> a

# < a,b | babaabbaababa=a >
babaabbaababa -> a
babaabbaabaa -> abaabbaababa
babaabbaaa -> aabbaababa

# < a,b | babaabbaabbaa=a >
babaabbaabbaa -> a

# < a,b | babaabbaabbba=a >
babaabbaabbba -> a
babaabbaabba -> abaabbaabbba
babaabbaaba -> abaabbaabba
babaabbaaa -> abaabbaaba

# < a,b | babaabbabaaaa=a >
babaabbabaaaa -> a

# < a,b | babaabbabaaba=a >
babaabbabaaba -> a
babaabbabaaa -> abaabbabaaba

# < a,b | babaabbababaa=a >
babaabbababaa -> a
babaabbaa -> abbababaa

# < a,b | babaabbabbaaa=a >
babaabbabbaaa -> a

# < a,b | babaabbabbaba=a >
babaabbabbaba -> a
babaabbabbaa -> abaabbabbaba
babaabbaba -> aabbabbaba
babaabbaa -> aabbabbaa
babaaba -> aabbaba
babaaa -> aabbaa

# < a,b | babaabbabbbaa=a >
babaabbabbbaa -> a

# < a,b | babaabbbaaaaa=a >
babaabbbaaaaa -> a

# < a,b | babaabbbaaaba=a >
babaabbbaaaba -> a
babaabbbaaaa -> abaabbbaaaba

# < a,b | babaabbbaabaa=a >
babaabbbaabaa -> a

# < a,b | babaabbbaabba=a >
babaabbbaabba -> a
babaabbbaaba -> abaabbbaabba
babaabbbaaa -> abaabbbaaba

# < a,b | babaabbbabaaa=a >
babaabbbabaaa -> a

# < a,b | babaabbbabbaa=a >
babaabbbabbaa -> a

# < a,b | babaabbbbaaaa=a >
babaabbbbaaaa -> a

# < a,b | babaabbbbaaba=a >
babaabbbbaaba -> a
babaabbbbaaa -> abaabbbbaaba

# < a,b | babaabbbbbaaa=a >
babaabbbbbaaa -> a

# < a,b | babaabbbbbbaa=a >
babaabbbbbbaa -> a

# < a,b | babaabbbbbbba=a >
babaabbbbbbba -> a
babaabbbbbba -> abaabbbbbbba
babaabbbbba -> abaabbbbbba
babaabbbba -> abaabbbbba
babaabbba -> abaabbbba
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaaaaaa=a >
bababaaaaaaaa -> a

# < a,b | bababaaaaaaba=a >
bababaaaaaaba -> a
bababaaaaaaa -> ababaaaaaaba

# < a,b | bababaaaaabaa=a >
bababaaaaabaa -> a

# < a,b | bababaaaaabba=a >
bababaaaaabba -> a
bababaaaaaba -> ababaaaaabba
bababaaaaaa -> ababaaaaaba

# < a,b | bababaaaabaaa=a >
bababaaaabaaa -> a

# < a,b | bababaaaababa=a >
bababaaaababa -> a
bababaaaabaa -> ababaaaababa
bababaaaaa -> abaaaababa

# < a,b | bababaaaabbaa=a >
bababaaaabbaa -> a

# < a,b | bababaaaabbba=a >
bababaaaabbba -> a
bababaaaabba -> ababaaaabbba
bababaaaaba -> ababaaaabba
bababaaaaa -> ababaaaaba

# < a,b | bababaaabaaaa=a >
bababaaabaaaa -> a

# < a,b | bababaaabaaba=a >
bababaaabaaba -> a
bababaaabaaa -> ababaaabaaba

# < a,b | bababaaababaa=a >
bababaaababaa -> a

# < a,b | bababaaabbaaa=a >
bababaaabbaaa -> a

# < a,b | bababaaabbaba=a >
bababaaabbaba -> a
bababaaabbaa -> ababaaabbaba
bababaaaba -> abaaabbaba
bababaaaa -> abaaabbaa

# < a,b | bababaaabbbaa=a >
bababaaabbbaa -> a

# < a,b | bababaaabbbba=a >
bababaaabbbba -> a
bababaaabbba -> ababaaabbbba
bababaaabba -> ababaaabbba
bababaaaba -> ababaaabba
bababaaaa -> ababaaaba

# < a,b | bababaabaaaaa=a >
bababaabaaaaa -> a

# < a,b | bababaabaaaba=a >
bababaabaaaba -> a
bababaabaaaa -> ababaabaaaba

# < a,b | bababaabaabaa=a >
bababaabaabaa -> a

# < a,b | bababaabaabba=a >
bababaabaabba -> a
bababaabaaba -> ababaabaabba
bababaabaaa -> ababaabaaba

# < a,b | bababaababaaa=a >
bababaababaaa -> a

# < a,b | bababaabababa=a >
bababaabababa -> a
bababaababaa -> ababaabababa
bababaabaa -> abaabababa
bababaaa -> aabababa

# < a,b | bababaababbaa=a >
bababaababbaa -> a

# < a,b | bababaabbaaaa=a >
bababaabbaaaa -> a

# < a,b | bababaabbaaba=a >
bababaabbaaba -> a
bababaabbaaa -> ababaabbaaba

# < a,b | bababaabbabaa=a >
bababaabbabaa -> a

# < a,b | bababaabbbaaa=a >
bababaabbbaaa -> a

# < a,b | bababaabbbbaa=a >
bababaabbbbaa -> a

# < a,b | bababaabbbbba=a >
bababaabbbbba -> a
bababaabbbba -> ababaabbbbba
bababaabbba -> ababaabbbba
bababaabba -> ababaabbba
bababaaba -> ababaabba
bababaaa -> ababaaba

# < a,b | babababaaaaaa=a >
babababaaaaaa -> a

# < a,b | babababaaaaba=a >
babababaaaaba -> a
babababaaaaa -> abababaaaaba

# < a,b | babababaaabaa=a >
babababaaabaa -> a

# < a,b | babababaaabba=a >
babababaaabba -> a
babababaaaba -> abababaaabba
babababaaaa -> abababaaaba

# < a,b | babababaabaaa=a >
babababaabaaa -> a

# < a,b | babababaababa=a >
babababaababa -> a
babababaabaa -> abababaababa
babababaaa -> ababaababa

# < a,b | babababaabbaa=a >
babababaabbaa -> a

# < a,b | babababaabbba=a >
babababaabbba -> a
babababaabba -> abababaabbba
babababaaba -> abababaabba
babababaaa -> abababaaba

# < a,b | bababababaaaa=a >
bababababaaaa -> a

# < a,b | bababababaaba=a >
bababababaaba -> a
bababababaaa -> ababababaaba

# < a,b | babababababaa=a >
babababababaa -> a

# < a,b | bababababbaaa=a >
bababababbaaa -> a

# < a,b | bababababbbaa=a >
bababababbbaa -> a

# < a,b | babababbaaaaa=a >
babababbaaaaa -> a

# < a,b | babababbaaaba=a >
babababbaaaba -> a
babababbaaaa -> abababbaaaba

# < a,b | babababbaabaa=a >
babababbaabaa -> a

# < a,b | babababbaabba=a >
babababbaabba -> a
babababbaaba -> abababbaabba
babababbaaa -> abababbaaba

# < a,b | babababbabaaa=a >
babababbabaaa -> a

# < a,b | babababbababa=a >
babababbababa -> a
babababa -> abbababa
baa -> aba

# < a,b | babababbabbaa=a >
babababbabbaa -> a

# < a,b | babababbbaaaa=a >
babababbbaaaa -> a

# < a,b | babababbbaaba=a >
babababbbaaba -> a
babababbbaaa -> abababbbaaba

# < a,b | babababbbabaa=a >
babababbbabaa -> a

# < a,b | babababbbbaaa=a >
babababbbbaaa -> a

# < a,b | babababbbbbaa=a >
babababbbbbaa -> a

# < a,b | bababbaaaaaaa=a >
bababbaaaaaaa -> a

# < a,b | bababbaaaaaba=a >
bababbaaaaaba -> a
bababbaaaaaa -> ababbaaaaaba

# < a,b | bababbaaaabaa=a >
bababbaaaabaa -> a

# < a,b | bababbaaaabba=a >
bababbaaaabba -> a
bababbaaaaba -> ababbaaaabba
bababbaaaaa -> ababbaaaaba

# < a,b | bababbaaabaaa=a >
bababbaaabaaa -> a

# < a,b | bababbaaababa=a >
bababbaaababa -> a
bababbaaabaa -> ababbaaababa
bababbaaaa -> abbaaababa

# < a,b | bababbaaabbaa=a >
bababbaaabbaa -> a

# < a,b | bababbaaabbba=a >
bababbaaabbba -> a
bababbaaabba -> ababbaaabbba
bababbaaaba -> ababbaaabba
bababbaaaa -> ababbaaaba

# < a,b | bababbaabaaaa=a >
bababbaabaaaa -> a

# < a,b | bababbaabaaba=a >
bababbaabaaba -> a
bababbaabaaa -> ababbaabaaba

# < a,b | bababbaababaa=a >
bababbaababaa -> a

# < a,b | bababbaabbaaa=a >
bababbaabbaaa -> a

# < a,b | bababbaabbaba=a >
bababbaabbaba -> a
bababbaabbaa -> ababbaabbaba
bababbaaba -> abbaabbaba
bababbaaa -> abbaabbaa

# < a,b | bababbaabbbaa=a >
bababbaabbbaa -> a

# < a,b | bababbaabbbba=a >
bababbaabbbba -> a
bababbaabbba -> ababbaabbbba
bababbaabba -> ababbaabbba
bababbaaba -> ababbaabba
bababbaaa -> ababbaaba

# < a,b | bababbabaaaaa=a >
bababbabaaaaa -> a

# < a,b | bababbabaaaba=a >
bababbabaaaba -> a
bababbabaaaa -> ababbabaaaba

# < a,b | bababbabaabaa=a >
bababbabaabaa -> a

# < a,b | bababbabaabba=a >
bababbabaabba -> a
bababbabaaba -> ababbabaabba
bababbabaaa -> ababbabaaba

# < a,b | bababbababaaa=a >
bababbababaaa -> a

# < a,b | bababbabababa=a >
bababbabababa -> a
bababbababaa -> ababbabababa
bababbabaa -> abbabababa

# < a,b | bababbababbaa=a >
bababbababbaa -> a

# < a,b | bababbabbaaaa=a >
bababbabbaaaa -> a

# < a,b | bababbabbaaba=a >
bababbabbaaba -> a
bababbabbaaa -> ababbabbaaba

# < a,b | bababbabbabaa=a >
bababbabbabaa -> a

# < a,b | bababbabbbaaa=a >
bababbabbbaaa -> a

# < a,b | bababbabbbbaa=a >
bababbabbbbaa -> a

# < a,b | bababbbaaaaaa=a >
bababbbaaaaaa -> a

# < a,b | bababbbaaaaba=a >
bababbbaaaaba -> a
bababbbaaaaa -> ababbbaaaaba

# < a,b | bababbbaaabaa=a >
bababbbaaabaa -> a

# < a,b | bababbbaaabba=a >
bababbbaaabba -> a
bababbbaaaba -> ababbbaaabba
bababbbaaaa -> ababbbaaaba

# < a,b | bababbbaabaaa=a >
bababbbaabaaa -> a

# < a,b | bababbbaababa=a >
bababbbaababa -> a
bababbbaabaa -> ababbbaababa
bababbbaaa -> abbbaababa

# < a,b | bababbbaabbaa=a >
bababbbaabbaa -> a

# < a,b | bababbbaabbba=a >
bababbbaabbba -> a
bababbbaabba -> ababbbaabbba
bababbbaaba -> ababbbaabba
bababbbaaa -> ababbbaaba

# < a,b | bababbbabaaaa=a >
bababbbabaaaa -> a

# < a,b | bababbbabaaba=a >
bababbbabaaba -> a
bababbbabaaa -> ababbbabaaba

# < a,b | bababbbababaa=a >
bababbbababaa -> a

# < a,b | bababbbabbaaa=a >
bababbbabbaaa -> a

# < a,b | bababbbabbbaa=a >
bababbbabbbaa -> a

# < a,b | bababbbbaaaaa=a >
bababbbbaaaaa -> a

# < a,b | bababbbbaaaba=a >
bababbbbaaaba -> a
bababbbbaaaa -> ababbbbaaaba

# < a,b | bababbbbaabaa=a >
bababbbbaabaa -> a

# < a,b | bababbbbaabba=a >
bababbbbaabba -> a
bababbbbaaba -> ababbbbaabba
bababbbbaaa -> ababbbbaaba

# < a,b | bababbbbabaaa=a >
bababbbbabaaa -> a

# < a,b | bababbbbababa=a >
bababbbbababa -> a
bababbbbabaa -> ababbbbababa
bababbbbaa -> abbbbababa

# < a,b | bababbbbabbaa=a >
bababbbbabbaa -> a

# < a,b | bababbbbbaaaa=a >
bababbbbbaaaa -> a

# < a,b | bababbbbbaaba=a >
bababbbbbaaba -> a
bababbbbbaaa -> ababbbbbaaba

# < a,b | bababbbbbabaa=a >
bababbbbbabaa -> a

# < a,b | bababbbbbbaaa=a >
bababbbbbbaaa -> a

# < a,b | bababbbbbbbaa=a >
bababbbbbbbaa -> a

# < a,b | babbaaaaaaaaa=a >
babbaaaaaaaaa -> a

# < a,b | babbaaaaaaaba=a >
babbaaaaaaaba -> a
babbaaaaaaaa -> abbaaaaaaaba

# < a,b | babbaaaaaabaa=a >
babbaaaaaabaa -> a

# < a,b | babbaaaaaabba=a >
babbaaaaaabba -> a
babbaaaaaaba -> abbaaaaaabba
babbaaaaaaa -> abbaaaaaaba

# < a,b | babbaaaaabaaa=a >
babbaaaaabaaa -> a

# < a,b | babbaaaaababa=a >
babbaaaaababa -> a
babbaaaaabaa -> abbaaaaababa

# < a,b | babbaaaaabbaa=a >
babbaaaaabbaa -> a

# < a,b | babbaaaaabbba=a >
babbaaaaabbba -> a
babbaaaaabba -> abbaaaaabbba
babbaaaaaba -> abbaaaaabba
babbaaaaaa -> abbaaaaaba

# < a,b | babbaaaabaaaa=a >
babbaaaabaaaa -> a

# < a,b | babbaaaabaaba=a >
babbaaaabaaba -> a
babbaaaabaaa -> abbaaaabaaba

# < a,b | babbaaaababaa=a >
babbaaaababaa -> a

# < a,b | babbaaaababba=a >
babbaaaababba -> a
babbaaaababa -> abbaaaababba
babbaaaaa -> aaaababba
babbaaaabaa -> abbaaaababa

# < a,b | babbaaaabbaaa=a >
babbaaaabbaaa -> a

# < a,b | babbaaaabbaba=a >
babbaaaabbaba -> a
babbaaaabbaa -> abbaaaabbaba

# < a,b | babbaaaabbbaa=a >
babbaaaabbbaa -> a

# < a,b | babbaaaabbbba=a >
babbaaaabbbba -> a
babbaaaabbba -> abbaaaabbbba
babbaaaabba -> abbaaaabbba
babbaaaaba -> abbaaaabba
babbaaaaa -> abbaaaaba

# < a,b | babbaaabaaaaa=a >
babbaaabaaaaa -> a

# < a,b | babbaaabaaaba=a >
babbaaabaaaba -> a
babbaaabaaaa -> abbaaabaaaba

# < a,b | babbaaabaabaa=a >
babbaaabaabaa -> a

# < a,b | babbaaabaabba=a >
babbaaabaabba -> a
babbaaabaaba -> abbaaabaabba
babbaaabaaa -> abbaaabaaba

# < a,b | babbaaababaaa=a >
babbaaababaaa -> a

# < a,b | babbaaabababa=a >
babbaaabababa -> a
babbaaababaa -> abbaaabababa

# < a,b | babbaaababbaa=a >
babbaaababbaa -> a
babbaaaa -> aababbaa

# < a,b | babbaaabbaaaa=a >
babbaaabbaaaa -> a

# < a,b | babbaaabbaaba=a >
babbaaabbaaba -> a
babbaaabbaaa -> abbaaabbaaba

# < a,b | babbaaabbabaa=a >
babbaaabbabaa -> a

# < a,b | babbaaabbabba=a >
babbaaabbabba -> a
babbaaabbaba -> abbaaabbabba
babbaaaba -> aaabbabba
babbaaabbaa -> abbaaabbaba
babbaaaa -> aaabbaba

# < a,b | babbaaabbbaaa=a >
babbaaabbbaaa -> a

# < a,b | babbaaabbbaba=a >
babbaaabbbaba -> a
babbaaabbbaa -> abbaaabbbaba

# < a,b | babbaaabbbbaa=a >
babbaaabbbbaa -> a

# < a,b | babbaaabbbbba=a >
babbaaabbbbba -> a
babbaaabbbba -> abbaaabbbbba
babbaaabbba -> abbaaabbbba
babbaaabba -> abbaaabbba
babbaaaba -> abbaaabba
babbaaaa -> abbaaaba

# < a,b | babbaabaaaaaa=a >
babbaabaaaaaa -> a

# < a,b | babbaabaaaaba=a >
babbaabaaaaba -> a
babbaabaaaaa -> abbaabaaaaba

# < a,b | babbaabaaabaa=a >
babbaabaaabaa -> a

# < a,b | babbaabaaabba=a >
babbaabaaabba -> a
babbaabaaaba -> abbaabaaabba
babbaabaaaa -> abbaabaaaba

# < a,b | babbaabaabaaa=a >
babbaabaabaaa -> a

# < a,b | babbaabaababa=a >
babbaabaababa -> a
babbaabaabaa -> abbaabaababa

# < a,b | babbaabaabbaa=a >
babbaabaabbaa -> a

# < a,b | babbaabaabbba=a >
babbaabaabbba -> a
babbaabaabba -> abbaabaabbba
babbaabaaba -> abbaabaabba
babbaabaaa -> abbaabaaba

# < a,b | babbaababaaaa=a >
babbaababaaaa -> a

# < a,b | babbaababaaba=a >
babbaababaaba -> a
babbaababaaa -> abbaababaaba

# < a,b | babbaabababaa=a >
babbaabababaa -> a

# < a,b | babbaabababba=a >
babbaabababba -> a
babbaabababa -> abbaabababba
babbaabaa -> aabababba
babbaababaa -> abbaabababa

# < a,b | babbaababbaaa=a >
babbaababbaaa -> a

# < a,b | babbaababbbaa=a >
babbaababbbaa -> a

# < a,b | babbaabbaaaaa=a >
babbaabbaaaaa -> a

# < a,b | babbaabbaaaba=a >
babbaabbaaaba -> a
babbaabbaaaa -> abbaabbaaaba

# < a,b | babbaabbaabaa=a >
babbaabbaabaa -> a

# < a,b | babbaabbaabba=a >
babbaabbaabba -> a
babbaabbaaba -> abbaabbaabba
babbaabbaaa -> abbaabbaaba

# < a,b | babbaabbabaaa=a >
babbaabbabaaa -> a

# < a,b | babbaabbababa=a >
babbaabbababa -> a
babbaabbabaa -> abbaabbababa

# < a,b | babbaabbbaaaa=a >
babbaabbbaaaa -> a

# < a,b | babbaabbbaaba=a >
babbaabbbaaba -> a
babbaabbbaaa -> abbaabbbaaba

# < a,b | babbaabbbabaa=a >
babbaabbbabaa -> a

# < a,b | babbaabbbabba=a >
babbaabbbabba -> a
babbaabbbaba -> abbaabbbabba
babbaabba -> aabbbabba
babbaabbbaa -> abbaabbbaba
babbaaba -> aabbbaba
babbaaa -> aabbbaa

# < a,b | babbaabbbbaaa=a >
babbaabbbbaaa -> a

# < a,b | babbaabbbbaba=a >
babbaabbbbaba -> a
babbaabbbbaa -> abbaabbbbaba

# < a,b | babbaabbbbbaa=a >
babbaabbbbbaa -> a

# < a,b | babbaabbbbbba=a >
babbaabbbbbba -> a
babbaabbbbba -> abbaabbbbbba
babbaabbbba -> abbaabbbbba
babbaabbba -> abbaabbbba
babbaabba -> abbaabbba
babbaaba -> abbaabba
babbaaa -> abbaaba

# < a,b | babbabaaaaaaa=a >
babbabaaaaaaa -> a

# < a,b | babbabaaaaaba=a >
babbabaaaaaba -> a
babbabaaaaaa -> abbabaaaaaba

# < a,b | babbabaaaabaa=a >
babbabaaaabaa -> a

# < a,b | babbabaaaabba=a >
babbabaaaabba -> a
babbabaaaaba -> abbabaaaabba
babbabaaaaa -> abbabaaaaba

# < a,b | babbabaaabaaa=a >
babbabaaabaaa -> a

# < a,b | babbabaaababa=a >
babbabaaababa -> a
babbabaaabaa -> abbabaaababa

# < a,b | babbabaaabbaa=a >
babbabaaabbaa -> a

# < a,b | babbabaaabbba=a >
babbabaaabbba -> a
babbabaaabba -> abbabaaabbba
babbabaaaba -> abbabaaabba
babbabaaaa -> abbabaaaba

# < a,b | babbabaabaaaa=a >
babbabaabaaaa -> a

# < a,b | babbabaabaaba=a >
babbabaabaaba -> a
babbabaabaaa -> abbabaabaaba

# < a,b | babbabaababaa=a >
babbabaababaa -> a

# < a,b | babbabaababba=a >
babbabaababba -> a
babbabaababa -> abbabaababba
babbabaaa -> abaababba
babbabaabaa -> abbabaababa

# < a,b | babbabaabbaaa=a >
babbabaabbaaa -> a

# < a,b | babbabaabbaba=a >
babbabaabbaba -> a
babbabaabbaa -> abbabaabbaba

# < a,b | babbabaabbbaa=a >
babbabaabbbaa -> a

# < a,b | babbabaabbbba=a >
babbabaabbbba -> a
babbabaabbba -> abbabaabbbba
babbabaabba -> abbabaabbba
babbabaaba -> abbabaabba
babbabaaa -> abbabaaba

# < a,b | babbababaaaaa=a >
babbababaaaaa -> a

# < a,b | babbababaaaba=a >
babbababaaaba -> a
babbababaaaa -> abbababaaaba

# < a,b | babbababaabaa=a >
babbababaabaa -> a

# < a,b | babbababaabba=a >
babbababaabba -> a
babbababaaba -> abbababaabba
babbababaaa -> abbababaaba

# < a,b | babbabababaaa=a >
babbabababaaa -> a

# < a,b | babbababababa=a >
babbababababa -> a
babbabababaa -> abbababababa

# < a,b | babbabababbaa=a >
babbabababbaa -> a

# < a,b | babbababbaaaa=a >
babbababbaaaa -> a

# < a,b | babbababbaaba=a >
babbababbaaba -> a
babbababbaaa -> abbababbaaba

# < a,b | babbababbabaa=a >
babbababbabaa -> a

# < a,b | babbababbbaaa=a >
babbababbbaaa -> a

# < a,b | babbababbbaba=a >
babbababbbaba -> a
babbababbbaa -> abbababbbaba

# < a,b | babbababbbbaa=a >
babbababbbbaa -> a

# < a,b | babbabbaaaaaa=a >
babbabbaaaaaa -> a

# < a,b | babbabbaaaaba=a >
babbabbaaaaba -> a
babbabbaaaaa -> abbabbaaaaba

# < a,b | babbabbaaabaa=a >
babbabbaaabaa -> a

# < a,b | babbabbaaabba=a >
babbabbaaabba -> a
babbabbaaaba -> abbabbaaabba
babbabbaaaa -> abbabbaaaba

# < a,b | babbabbaabaaa=a >
babbabbaabaaa -> a

# < a,b | babbabbaababa=a >
babbabbaababa -> a
babbabbaabaa -> abbabbaababa

# < a,b | babbabbaabbaa=a >
babbabbaabbaa -> a

# < a,b | babbabbaabbba=a >
babbabbaabbba -> a
babbabbaabba -> abbabbaabbba
babbabbaaba -> abbabbaabba
babbabbaaa -> abbabbaaba

# < a,b | babbabbabaaaa=a >
babbabbabaaaa -> a

# < a,b | babbabbabaaba=a >
babbabbabaaba -> a
babbabbabaaa -> abbabbabaaba

# < a,b | babbabbababaa=a >
babbabbababaa -> a

# < a,b | babbabbababba=a >
babbabbababba -> a
babbabbababa -> abbabbababba
babbabbaa -> abbababba
babbabbabaa -> abbabbababa

# < a,b | babbabbabbaaa=a >
babbabbabbaaa -> a

# < a,b | babbabbabbaba=a >
babbabbabbaba -> a
babbabbabbaa -> abbabbabbaba

# < a,b | babbabbabbbaa=a >
babbabbabbbaa -> a

# < a,b | babbabbbaaaaa=a >
babbabbbaaaaa -> a

# < a,b | babbabbbaaaba=a >
babbabbbaaaba -> a
babbabbbaaaa -> abbabbbaaaba

# < a,b | babbabbbaabaa=a >
babbabbbaabaa -> a

# < a,b | babbabbbaabba=a >
babbabbbaabba -> a
babbabbbaaba -> abbabbbaabba
babbabbbaaa -> abbabbbaaba

# < a,b | babbabbbabaaa=a >
babbabbbabaaa -> a

# < a,b | babbabbbababa=a >
babbabbbababa -> a
babbabbbabaa -> abbabbbababa

# < a,b | babbabbbabbaa=a >
babbabbbabbaa -> a

# < a,b | babbabbbbaaaa=a >
babbabbbbaaaa -> a

# < a,b | babbabbbbaaba=a >
babbabbbbaaba -> a
babbabbbbaaa -> abbabbbbaaba

# < a,b | babbabbbbabaa=a >
babbabbbbabaa -> a

# < a,b | babbabbbbbaaa=a >
babbabbbbbaaa -> a

# < a,b | babbabbbbbaba=a >
babbabbbbbaba -> a
babbabbbbbaa -> abbabbbbbaba

# < a,b | babbabbbbbbaa=a >
babbabbbbbbaa -> a

# < a,b | babbbaaaaaaaa=a >
babbbaaaaaaaa -> a

# < a,b | babbbaaaaaaba=a >
babbbaaaaaaba -> a
babbbaaaaaaa -> abbbaaaaaaba

# < a,b | babbbaaaaabaa=a >
babbbaaaaabaa -> a

# < a,b | babbbaaaaabba=a >
babbbaaaaabba -> a
babbbaaaaaba -> abbbaaaaabba
babbbaaaaaa -> abbbaaaaaba

# < a,b | babbbaaaabaaa=a >
babbbaaaabaaa -> a

# < a,b | babbbaaaababa=a >
babbbaaaababa -> a
babbbaaaabaa -> abbbaaaababa

# < a,b | babbbaaaabbaa=a >
babbbaaaabbaa -> a

# < a,b | babbbaaaabbba=a >
babbbaaaabbba -> a
babbbaaaabba -> abbbaaaabbba
babbbaaaaba -> abbbaaaabba
babbbaaaaa -> abbbaaaaba

# < a,b | babbbaaabaaaa=a >
babbbaaabaaaa -> a

# < a,b | babbbaaabaaba=a >
babbbaaabaaba -> a
babbbaaabaaa -> abbbaaabaaba

# < a,b | babbbaaababaa=a >
babbbaaababaa -> a

# < a,b | babbbaaababba=a >
babbbaaababba -> a
babbbaaababa -> abbbaaababba
babbbaaabaa -> abbbaaababa

# < a,b | babbbaaabbaaa=a >
babbbaaabbaaa -> a

# < a,b | babbbaaabbaba=a >
babbbaaabbaba -> a
babbbaaabbaa -> abbbaaabbaba

# < a,b | babbbaaabbbaa=a >
babbbaaabbbaa -> a

# < a,b | babbbaaabbbba=a >
babbbaaabbbba -> a
babbbaaabbba -> abbbaaabbbba
babbbaaabba -> abbbaaabbba
babbbaaaba -> abbbaaabba
babbbaaaa -> abbbaaaba

# < a,b | babbbaabaaaaa=a >
babbbaabaaaaa -> a

# < a,b | babbbaabaaaba=a >
babbbaabaaaba -> a
babbbaabaaaa -> abbbaabaaaba

# < a,b | babbbaabaabaa=a >
babbbaabaabaa -> a

# < a,b | babbbaabaabba=a >
babbbaabaabba -> a
babbbaabaaba -> abbbaabaabba
babbbaabaaa -> abbbaabaaba

# < a,b | babbbaababaaa=a >
babbbaababaaa -> a

# < a,b | babbbaabababa=a >
babbbaabababa -> a
babbbaababaa -> abbbaabababa

# < a,b | babbbaababbaa=a >
babbbaababbaa -> a

# < a,b | babbbaababbba=a >
babbbaababbba -> a
babbbaababba -> abbbaababbba
babbbaaa -> aababbba
babbbaababa -> abbbaababba
babbbaabaa -> abbbaababa

# < a,b | babbbaabbaaaa=a >
babbbaabbaaaa -> a

# < a,b | babbbaabbaaba=a >
babbbaabbaaba -> a
babbbaabbaaa -> abbbaabbaaba

# < a,b | babbbaabbabaa=a >
babbbaabbabaa -> a

# < a,b | babbbaabbabba=a >
babbbaabbabba -> a
babbbaabbaba -> abbbaabbabba
babbbaabbaa -> abbbaabbaba

# < a,b | babbbaabbbaaa=a >
babbbaabbbaaa -> a

# < a,b | babbbaabbbaba=a >
babbbaabbbaba -> a
babbbaabbbaa -> abbbaabbbaba

# < a,b | babbbaabbbbaa=a >
babbbaabbbbaa -> a

# < a,b | babbbaabbbbba=a >
babbbaabbbbba -> a
babbbaabbbba -> abbbaabbbbba
babbbaabbba -> abbbaabbbba
babbbaabba -> abbbaabbba
babbbaaba -> abbbaabba
babbbaaa -> abbbaaba

# < a,b | babbbabaaaaaa=a >
babbbabaaaaaa -> a

# < a,b | babbbabaaaaba=a >
babbbabaaaaba -> a
babbbabaaaaa -> abbbabaaaaba

# < a,b | babbbabaaabaa=a >
babbbabaaabaa -> a

# < a,b | babbbabaaabba=a >
babbbabaaabba -> a
babbbabaaaba -> abbbabaaabba
babbbabaaaa -> abbbabaaaba

# < a,b | babbbabaabaaa=a >
babbbabaabaaa -> a

# < a,b | babbbabaababa=a >
babbbabaababa -> a
babbbabaabaa -> abbbabaababa

# < a,b | babbbabaabbaa=a >
babbbabaabbaa -> a

# < a,b | babbbabaabbba=a >
babbbabaabbba -> a
babbbabaabba -> abbbabaabbba
babbbabaaba -> abbbabaabba
babbbabaaa -> abbbabaaba

# < a,b | babbbababaaaa=a >
babbbababaaaa -> a

# < a,b | babbbababaaba=a >
babbbababaaba -> a
babbbababaaa -> abbbababaaba

# < a,b | babbbabababaa=a >
babbbabababaa -> a

# < a,b | babbbabababba=a >
babbbabababba -> a
babbbabababa -> abbbabababba
babbbababaa -> abbbabababa

# < a,b | babbbababbaaa=a >
babbbababbaaa -> a

# < a,b | babbbababbaba=a >
babbbababbaba -> a
babbbababbaa -> abbbababbaba

# < a,b | babbbababbbaa=a >
babbbababbbaa -> a

# < a,b | babbbabbaaaaa=a >
babbbabbaaaaa -> a

# < a,b | babbbabbaaaba=a >
babbbabbaaaba -> a
babbbabbaaaa -> abbbabbaaaba

# < a,b | babbbabbaabaa=a >
babbbabbaabaa -> a

# < a,b | babbbabbaabba=a >
babbbabbaabba -> a
babbbabbaaba -> abbbabbaabba
babbbabbaaa -> abbbabbaaba

# < a,b | babbbabbabaaa=a >
babbbabbabaaa -> a

# < a,b | babbbabbababa=a >
babbbabbababa -> a
babbbabbabaa -> abbbabbababa

# < a,b | babbbabbabbaa=a >
babbbabbabbaa -> a

# < a,b | babbbabbabbba=a >
babbbabbabbba -> a
babbbabbabba -> abbbabbabbba
babbbaba -> abbabbba
babbbabbaba -> abbbabbabba
babbbaa -> abbabba
babbbabbaa -> abbbabbaba

# < a,b | babbbabbbaaaa=a >
babbbabbbaaaa -> a

# < a,b | babbbabbbaaba=a >
babbbabbbaaba -> a
babbbabbbaaa -> abbbabbbaaba

# < a,b | babbbabbbabaa=a >
babbbabbbabaa -> a

# < a,b | babbbabbbabba=a >
babbbabbbabba -> a
babbbabbbaba -> abbbabbbabba
babbbabbbaa -> abbbabbbaba

# < a,b | babbbabbbbaaa=a >
babbbabbbbaaa -> a

# < a,b | babbbabbbbaba=a >
babbbabbbbaba -> a
babbbabbbbaa -> abbbabbbbaba

# < a,b | babbbabbbbbaa=a >
babbbabbbbbaa -> a

# < a,b | babbbbaaaaaaa=a >
babbbbaaaaaaa -> a

# < a,b | babbbbaaaaaba=a >
babbbbaaaaaba -> a
babbbbaaaaaa -> abbbbaaaaaba

# < a,b | babbbbaaaabaa=a >
babbbbaaaabaa -> a

# < a,b | babbbbaaaabba=a >
babbbbaaaabba -> a
babbbbaaaaba -> abbbbaaaabba
babbbbaaaaa -> abbbbaaaaba

# < a,b | babbbbaaabaaa=a >
babbbbaaabaaa -> a

# < a,b | babbbbaaababa=a >
babbbbaaababa -> a
babbbbaaabaa -> abbbbaaababa

# < a,b | babbbbaaabbaa=a >
babbbbaaabbaa -> a

# < a,b | babbbbaaabbba=a >
babbbbaaabbba -> a
babbbbaaabba -> abbbbaaabbba
babbbbaaaba -> abbbbaaabba
babbbbaaaa -> abbbbaaaba

# < a,b | babbbbaabaaaa=a >
babbbbaabaaaa -> a

# < a,b | babbbbaabaaba=a >
babbbbaabaaba -> a
babbbbaabaaa -> abbbbaabaaba

# < a,b | babbbbaababaa=a >
babbbbaababaa -> a

# < a,b | babbbbaababba=a >
babbbbaababba -> a
babbbbaababa -> abbbbaababba
babbbbaabaa -> abbbbaababa

# < a,b | babbbbaabbaaa=a >
babbbbaabbaaa -> a

# < a,b | babbbbaabbaba=a >
babbbbaabbaba -> a
babbbbaabbaa -> abbbbaabbaba

# < a,b | babbbbaabbbaa=a >
babbbbaabbbaa -> a

# < a,b | babbbbaabbbba=a >
babbbbaabbbba -> a
babbbbaabbba -> abbbbaabbbba
babbbbaabba -> abbbbaabbba
babbbbaaba -> abbbbaabba
babbbbaaa -> abbbbaaba

# < a,b | babbbbabaaaaa=a >
babbbbabaaaaa -> a

# < a,b | babbbbabaaaba=a >
babbbbabaaaba -> a
babbbbabaaaa -> abbbbabaaaba

# < a,b | babbbbabaabaa=a >
babbbbabaabaa -> a

# < a,b | babbbbabaabba=a >
babbbbabaabba -> a
babbbbabaaba -> abbbbabaabba
babbbbabaaa -> abbbbabaaba

# < a,b | babbbbababaaa=a >
babbbbababaaa -> a

# < a,b | babbbbabababa=a >
babbbbabababa -> a
babbbbababaa -> abbbbabababa

# < a,b | babbbbababbaa=a >
babbbbababbaa -> a

# < a,b | babbbbababbba=a >
babbbbababbba -> a
babbbbababba -> abbbbababbba
babbbbababa -> abbbbababba
babbbbabaa -> abbbbababa

# < a,b | babbbbabbaaaa=a >
babbbbabbaaaa -> a

# < a,b | babbbbabbaaba=a >
babbbbabbaaba -> a
babbbbabbaaa -> abbbbabbaaba

# < a,b | babbbbabbabaa=a >
babbbbabbabaa -> a

# < a,b | babbbbabbabba=a >
babbbbabbabba -> a
babbbbabbaba -> abbbbabbabba
babbbbabbaa -> abbbbabbaba

# < a,b | babbbbabbbaaa=a >
babbbbabbbaaa -> a

# < a,b | babbbbabbbaba=a >
babbbbabbbaba -> a
babbbbabbbaa -> abbbbabbbaba

# < a,b | babbbbabbbbaa=a >
babbbbabbbbaa -> a

# < a,b | babbbbbaaaaaa=a >
babbbbbaaaaaa -> a

# < a,b | babbbbbaaaaba=a >
babbbbbaaaaba -> a
babbbbbaaaaa -> abbbbbaaaaba

# < a,b | babbbbbaaabaa=a >
babbbbbaaabaa -> a

# < a,b | babbbbbaaabba=a >
babbbbbaaabba -> a
babbbbbaaaba -> abbbbbaaabba
babbbbbaaaa -> abbbbbaaaba

# < a,b | babbbbbaabaaa=a >
babbbbbaabaaa -> a

# < a,b | babbbbbaababa=a >
babbbbbaababa -> a
babbbbbaabaa -> abbbbbaababa

# < a,b | babbbbbaabbaa=a >
babbbbbaabbaa -> a

# < a,b | babbbbbaabbba=a >
babbbbbaabbba -> a
babbbbbaabba -> abbbbbaabbba
babbbbbaaba -> abbbbbaabba
babbbbbaaa -> abbbbbaaba

# < a,b | babbbbbabaaaa=a >
babbbbbabaaaa -> a

# < a,b | babbbbbabaaba=a >
babbbbbabaaba -> a
babbbbbabaaa -> abbbbbabaaba

# < a,b | babbbbbababaa=a >
babbbbbababaa -> a

# < a,b | babbbbbababba=a >
babbbbbababba -> a
babbbbbababa -> abbbbbababba
babbbbbabaa -> abbbbbababa

# < a,b | babbbbbabbaaa=a >
babbbbbabbaaa -> a

# < a,b | babbbbbabbaba=a >
babbbbbabbaba -> a
babbbbbabbaa -> abbbbbabbaba

# < a,b | babbbbbabbbaa=a >
babbbbbabbbaa -> a

# < a,b | babbbbbabbbba=a >
babbbbbabbbba -> a
babbbbbabbba -> abbbbbabbbba
babbbbbabba -> abbbbbabbba
babbbbbaba -> abbbbbabba
babbbbbaa -> abbbbbaba

# < a,b | babbbbbbaaaaa=a >
babbbbbbaaaaa -> a

# < a,b | babbbbbbaaaba=a >
babbbbbbaaaba -> a
babbbbbbaaaa -> abbbbbbaaaba

# < a,b | babbbbbbaabaa=a >
babbbbbbaabaa -> a

# < a,b | babbbbbbaabba=a >
babbbbbbaabba -> a
babbbbbbaaba -> abbbbbbaabba
babbbbbbaaa -> abbbbbbaaba

# < a,b | babbbbbbabaaa=a >
babbbbbbabaaa -> a

# < a,b | babbbbbbababa=a >
babbbbbbababa -> a
babbbbbbabaa -> abbbbbbababa

# < a,b | babbbbbbabbaa=a >
babbbbbbabbaa -> a

# < a,b | babbbbbbabbba=a >
babbbbbbabbba -> a
babbbbbbabba -> abbbbbbabbba
babbbbbbaba -> abbbbbbabba
babbbbbbaa -> abbbbbbaba

# < a,b | babbbbbbbaaaa=a >
babbbbbbbaaaa -> a

# < a,b | babbbbbbbaaba=a >
babbbbbbbaaba -> a
babbbbbbbaaa -> abbbbbbbaaba

# < a,b | babbbbbbbabaa=a >
babbbbbbbabaa -> a

# < a,b | babbbbbbbabba=a >
babbbbbbbabba -> a
babbbbbbbaba -> abbbbbbbabba
babbbbbbbaa -> abbbbbbbaba

# < a,b | babbbbbbbbaaa=a >
babbbbbbbbaaa -> a

# < a,b | babbbbbbbbaba=a >
babbbbbbbbaba -> a
babbbbbbbbaa -> abbbbbbbbaba

# < a,b | babbbbbbbbbaa=a >
babbbbbbbbbaa -> a

# < a,b | babbbbbbbbbba=a >
babbbbbbbbbba -> a
babbbbbbbbba -> abbbbbbbbbba
babbbbbbbba -> abbbbbbbbba
babbbbbbba -> abbbbbbbba
babbbbbba -> abbbbbbba
babbbbba -> abbbbbba
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaaaaaaa=a >
bbaaaaaaaaaaa -> a

# < a,b | bbaaaaaaaaaba=a >
bbaaaaaaaaaba -> a

# < a,b | bbaaaaaaaabaa=a >
bbaaaaaaaabaa -> a

# < a,b | bbaaaaaaaabba=a >
bbaaaaaaaabba -> a
bbaaaaaaaaa -> aaaaaaaabba

# < a,b | bbaaaaaaabaaa=a >
bbaaaaaaabaaa -> a

# < a,b | bbaaaaaaababa=a >
bbaaaaaaababa -> a

# < a,b | bbaaaaaaabbaa=a >
bbaaaaaaabbaa -> a
bbaaaaaaaa -> aaaaaabbaa

# < a,b | bbaaaaaaabbba=a >
bbaaaaaaabbba -> a
bbaaaaaaaba -> aaaaaaabbba

# < a,b | bbaaaaaabaaaa=a >
bbaaaaaabaaaa -> a

# < a,b | bbaaaaaabaaba=a >
bbaaaaaabaaba -> a

# < a,b | bbaaaaaababaa=a >
bbaaaaaababaa -> a

# < a,b | bbaaaaaababba=a >
bbaaaaaababba -> a
bbaaaaaabaa -> aaaaaababba

# < a,b | bbaaaaaabbaaa=a >
bbaaaaaabbaaa -> a
bbaaaaaaa -> aaaabbaaa

# < a,b | bbaaaaaabbaba=a >
bbaaaaaabbaba -> a

# < a,b | bbaaaaaabbbaa=a >
bbaaaaaabbbaa -> a
bbaaaaaaba -> aaaaabbbaa

# < a,b | bbaaaaaabbbba=a >
bbaaaaaabbbba -> a
bbaaaaaabba -> aaaaaabbbba
bbaaaaaaa -> aaaaaabba

# < a,b | bbaaaaabaaaaa=a >
bbaaaaabaaaaa -> a

# < a,b | bbaaaaabaaaba=a >
bbaaaaabaaaba -> a

# < a,b | bbaaaaabaabaa=a >
bbaaaaabaabaa -> a

# < a,b | bbaaaaabaabba=a >
bbaaaaabaabba -> a
bbaaaaabaaa -> aaaaabaabba

# < a,b | bbaaaaababaaa=a >
bbaaaaababaaa -> a

# < a,b | bbaaaaabababa=a >
bbaaaaabababa -> a

# < a,b | bbaaaaababbaa=a >
bbaaaaababbaa -> a
bbaaaaabaa -> aaaababbaa

# < a,b | bbaaaaababbba=a >
bbaaaaababbba -> a
bbaaaaababa -> aaaaababbba

# < a,b | bbaaaaabbaaaa=a >
bbaaaaabbaaaa -> a
bbaaaaaa -> aabbaaaa

# < a,b | bbaaaaabbaaba=a >
bbaaaaabbaaba -> a

# < a,b | bbaaaaabbabaa=a >
bbaaaaabbabaa -> a

# < a,b | bbaaaaabbbaaa=a >
bbaaaaabbbaaa -> a
bbaaaaaba -> aaabbbaaa

# < a,b | bbaaaaabbbaba=a >
bbaaaaabbbaba -> a

# < a,b | bbaaaaabbbbba=a >
bbaaaaabbbbba -> a
bbaaaaabbba -> aaaaabbbbba
bbaaaaaba -> aaaaabbba

# < a,b | bbaaaabaaaaaa=a >
bbaaaabaaaaaa -> a

# < a,b | bbaaaabaaaaba=a >
bbaaaabaaaaba -> a

# < a,b | bbaaaabaaabaa=a >
bbaaaabaaabaa -> a

# < a,b | bbaaaabaaabba=a >
bbaaaabaaabba -> a
bbaaaabaaaa -> aaaabaaabba

# < a,b | bbaaaabaabaaa=a >
bbaaaabaabaaa -> a

# < a,b | bbaaaabaababa=a >
bbaaaabaababa -> a

# < a,b | bbaaaabaabbaa=a >
bbaaaabaabbaa -> a
bbaaaabaaa -> aaabaabbaa

# < a,b | bbaaaabaabbba=a >
bbaaaabaabbba -> a
bbaaaabaaba -> aaaabaabbba

# < a,b | bbaaaababaaaa=a >
bbaaaababaaaa -> a

# < a,b | bbaaaababaaba=a >
bbaaaababaaba -> a

# < a,b | bbaaaabababaa=a >
bbaaaabababaa -> a

# < a,b | bbaaaabababba=a >
bbaaaabababba -> a
bbaaaababaa -> aaaabababba

# < a,b | bbaaaababbaaa=a >
bbaaaababbaaa -> a
bbaaaabaa -> aababbaaa

# < a,b | bbaaaababbaba=a >
bbaaaababbaba -> a

# < a,b | bbaaaababbbaa=a >
bbaaaababbbaa -> a
bbaaaababa -> aaababbbaa

# < a,b | bbaaaababbbba=a >
bbaaaababbbba -> a
bbaaaababba -> aaaababbbba
bbaaaabaa -> aaaababba

# < a,b | bbaaaabbaaaaa=a >
bbaaaabbaaaaa -> a

# < a,b | bbaaaabbaaaba=a >
bbaaaabbaaaba -> a

# < a,b | bbaaaabbaabaa=a >
bbaaaabbaabaa -> a

# < a,b | bbaaaabbabaaa=a >
bbaaaabbabaaa -> a

# < a,b | bbaaaabbababa=a >
bbaaaabbababa -> a

# < a,b | bbaaaabbabbaa=a >
bbaaaabbabbaa -> a
bbaaaabbaa -> aaabbabbaa
bbaaaaa -> aaabbaa

# < a,b | bbaaaabbabbba=a >
bbaaaabbabbba -> a
bbaaaabbaba -> aaaabbabbba

# < a,b | bbaaaabbbaaaa=a >
bbaaaabbbaaaa -> a
bbaaaaba -> abbbaaaa

# < a,b | bbaaaabbbaaba=a >
bbaaaabbbaaba -> a

# < a,b | bbaaaabbbabaa=a >
bbaaaabbbabaa -> a

# < a,b | bbaaaabbbbaba=a >
bbaaaabbbbaba -> a

# < a,b | bbaaaabbbbbba=a >
bbaaaabbbbbba -> a
bbaaaabbbba -> aaaabbbbbba
bbaaaabba -> aaaabbbba
bbaaaaa -> aaaabba

# < a,b | bbaaabaaaaaaa=a >
bbaaabaaaaaaa -> a

# < a,b | bbaaabaaaaaba=a >
bbaaabaaaaaba -> a

# < a,b | bbaaabaaaabaa=a >
bbaaabaaaabaa -> a

# < a,b | bbaaabaaaabba=a >
bbaaabaaaabba -> a
bbaaabaaaaa -> aaabaaaabba

# < a,b | bbaaabaaabaaa=a >
bbaaabaaabaaa -> a

# < a,b | bbaaabaaababa=a >
bbaaabaaababa -> a

# < a,b | bbaaabaaabbaa=a >
bbaaabaaabbaa -> a
bbaaabaaaa -> aabaaabbaa

# < a,b | bbaaabaaabbba=a >
bbaaabaaabbba -> a
bbaaabaaaba -> aaabaaabbba

# < a,b | bbaaabaabaaaa=a >
bbaaabaabaaaa -> a

# < a,b | bbaaabaabaaba=a >
bbaaabaabaaba -> a

# < a,b | bbaaabaababaa=a >
bbaaabaababaa -> a

# < a,b | bbaaabaababba=a >
bbaaabaababba -> a
bbaaabaabaa -> aaabaababba

# < a,b | bbaaabaabbaaa=a >
bbaaabaabbaaa -> a
bbaaabaaa -> abaabbaaa

# < a,b | bbaaabaabbaba=a >
bbaaabaabbaba -> a

# < a,b | bbaaabaabbbaa=a >
bbaaabaabbbaa -> a
bbaaabaaba -> aabaabbbaa

# < a,b | bbaaabaabbbba=a >
bbaaabaabbbba -> a
bbaaabaabba -> aaabaabbbba
bbaaabaaa -> aaabaabba

# < a,b | bbaaababaaaaa=a >
bbaaababaaaaa -> a

# < a,b | bbaaababaaaba=a >
bbaaababaaaba -> a

# < a,b | bbaaababaabaa=a >
bbaaababaabaa -> a

# < a,b | bbaaababaabba=a >
bbaaababaabba -> a
bbaaababaaa -> aaababaabba

# < a,b | bbaaabababaaa=a >
bbaaabababaaa -> a

# < a,b | bbaaababababa=a >
bbaaababababa -> a

# < a,b | bbaaabababbaa=a >
bbaaabababbaa -> a
bbaaababaa -> aabababbaa

# < a,b | bbaaabababbba=a >
bbaaabababbba -> a
bbaaabababa -> aaabababbba

# < a,b | bbaaababbaaaa=a >
bbaaababbaaaa -> a

# < a,b | bbaaababbaaba=a >
bbaaababbaaba -> a

# < a,b | bbaaababbabaa=a >
bbaaababbabaa -> a

# < a,b | bbaaababbbaaa=a >
bbaaababbbaaa -> a
bbaaababa -> ababbbaaa

# < a,b | bbaaababbbaba=a >
bbaaababbbaba -> a

# < a,b | bbaaababbbbba=a >
bbaaababbbbba -> a
bbaaababbba -> aaababbbbba
bbaaababa -> aaababbba

# < a,b | bbaaabbaaaaaa=a >
bbaaabbaaaaaa -> a

# < a,b | bbaaabbaaaaba=a >
bbaaabbaaaaba -> a

# < a,b | bbaaabbaaabaa=a >
bbaaabbaaabaa -> a

# < a,b | bbaaabbaaabba=a >
bbaaabbaaabba -> a
bbaaaa -> aaabba

# < a,b | bbaaabbaabaaa=a >
bbaaabbaabaaa -> a

# < a,b | bbaaabbaababa=a >
bbaaabbaababa -> a

# < a,b | bbaaabbaabbba=a >
bbaaabbaabbba -> a
bbaaabbaaba -> aaabbaabbba

# < a,b | bbaaabbabaaaa=a >
bbaaabbabaaaa -> a

# < a,b | bbaaabbabaaba=a >
bbaaabbabaaba -> a

# < a,b | bbaaabbababaa=a >
bbaaabbababaa -> a

# < a,b | bbaaabbababba=a >
bbaaabbababba -> a
bbaaabbabaa -> aaabbababba

# < a,b | bbaaabbabbaba=a >
bbaaabbabbaba -> a

# < a,b | bbaaabbabbbaa=a >
bbaaabbabbbaa -> a
bbaaabbaba -> aabbabbbaa

# < a,b | bbaaabbbaaaaa=a >
bbaaabbbaaaaa -> a

# < a,b | bbaaabbbaaaba=a >
bbaaabbbaaaba -> a

# < a,b | bbaaabbbaabaa=a >
bbaaabbbaabaa -> a

# < a,b | bbaaabbbabaaa=a >
bbaaabbbabaaa -> a

# < a,b | bbaaabbbababa=a >
bbaaabbbababa -> a

# < a,b | bbaaabbbabbaa=a >
bbaaabbbabbaa -> a
bbaaabbbaa -> aabbbabbaa
bbaaaba -> aabbbaa

# < a,b | bbaaabbbabbba=a >
bbaaabbbabbba -> a
bbaaabbbaba -> aaabbbabbba

# < a,b | bbaaabbbbaaaa=a >
bbaaabbbbaaaa -> a

# < a,b | bbaaabbbbaaba=a >
bbaaabbbbaaba -> a

# < a,b | bbaaabbbbabaa=a >
bbaaabbbbabaa -> a

# < a,b | bbaaabbbbbaba=a >
bbaaabbbbbaba -> a

# < a,b | bbaaabbbbbbba=a >
bbaaabbbbbbba -> a
bbaaabbbbba -> aaabbbbbbba
bbaaabbba -> aaabbbbba
bbaaaba -> aaabbba

# < a,b | bbaabaaaaaaaa=a >
bbaabaaaaaaaa -> a

# < a,b | bbaabaaaaaaba=a >
bbaabaaaaaaba -> a

# < a,b | bbaabaaaaabaa=a >
bbaabaaaaabaa -> a

# < a,b | bbaabaaaaabba=a >
bbaabaaaaabba -> a
bbaabaaaaaa -> aabaaaaabba

# < a,b | bbaabaaaabaaa=a >
bbaabaaaabaaa -> a

# < a,b | bbaabaaaababa=a >
bbaabaaaababa -> a

# < a,b | bbaabaaaabbaa=a >
bbaabaaaabbaa -> a
bbaabaaaaa -> abaaaabbaa

# < a,b | bbaabaaaabbba=a >
bbaabaaaabbba -> a
bbaabaaaaba -> aabaaaabbba

# < a,b | bbaabaaabaaaa=a >
bbaabaaabaaaa -> a

# < a,b | bbaabaaabaaba=a >
bbaabaaabaaba -> a

# < a,b | bbaabaaababaa=a >
bbaabaaababaa -> a

# < a,b | bbaabaaababba=a >
bbaabaaababba -> a
bbaabaaabaa -> aabaaababba

# < a,b | bbaabaaabbaaa=a >
bbaabaaabbaaa -> a

# < a,b | bbaabaaabbaba=a >
bbaabaaabbaba -> a

# < a,b | bbaabaaabbbaa=a >
bbaabaaabbbaa -> a
bbaabaaaba -> abaaabbbaa

# < a,b | bbaabaaabbbba=a >
bbaabaaabbbba -> a
bbaabaaabba -> aabaaabbbba
bbaabaaaa -> aabaaabba

# < a,b | bbaabaabaaaaa=a >
bbaabaabaaaaa -> a

# < a,b | bbaabaabaaaba=a >
bbaabaabaaaba -> a

# < a,b | bbaabaabaabaa=a >
bbaabaabaabaa -> a

# < a,b | bbaabaabaabba=a >
bbaabaabaabba -> a
bbaabaabaaa -> aabaabaabba

# < a,b | bbaabaababaaa=a >
bbaabaababaaa -> a

# < a,b | bbaabaabababa=a >
bbaabaabababa -> a

# < a,b | bbaabaababbaa=a >
bbaabaababbaa -> a
bbaabaabaa -> abaababbaa

# < a,b | bbaabaababbba=a >
bbaabaababbba -> a
bbaabaababa -> aabaababbba

# < a,b | bbaabaabbaaaa=a >
bbaabaabbaaaa -> a

# < a,b | bbaabaabbaaba=a >
bbaabaabbaaba -> a
bbaabaaa -> aabbaaba

# < a,b | bbaabaabbabaa=a >
bbaabaabbabaa -> a

# < a,b | bbaabaabbbaaa=a >
bbaabaabbbaaa -> a

# < a,b | bbaabaabbbaba=a >
bbaabaabbbaba -> a

# < a,b | bbaabaabbbbba=a >
bbaabaabbbbba -> a
bbaabaabbba -> aabaabbbbba
bbaabaaba -> aabaabbba

# < a,b | bbaababaaaaaa=a >
bbaababaaaaaa -> a

# < a,b | bbaababaaaaba=a >
bbaababaaaaba -> a

# < a,b | bbaababaaabaa=a >
bbaababaaabaa -> a

# < a,b | bbaababaaabba=a >
bbaababaaabba -> a
bbaababaaaa -> aababaaabba

# < a,b | bbaababaabaaa=a >
bbaababaabaaa -> a

# < a,b | bbaababaababa=a >
bbaababaababa -> a

# < a,b | bbaababaabbaa=a >
bbaababaabbaa -> a
bbaababaaa -> ababaabbaa

# < a,b | bbaababaabbba=a >
bbaababaabbba -> a
bbaababaaba -> aababaabbba

# < a,b | bbaabababaaaa=a >
bbaabababaaaa -> a

# < a,b | bbaabababaaba=a >
bbaabababaaba -> a

# < a,b | bbaababababaa=a >
bbaababababaa -> a

# < a,b | bbaababababba=a >
bbaababababba -> a
bbaabababaa -> aababababba

# < a,b | bbaabababbaaa=a >
bbaabababbaaa -> a

# < a,b | bbaabababbaba=a >
bbaabababbaba -> a

# < a,b | bbaabababbbaa=a >
bbaabababbbaa -> a
bbaabababa -> abababbbaa

# < a,b | bbaabababbbba=a >
bbaabababbbba -> a
bbaabababba -> aabababbbba
bbaababaa -> aabababba

# < a,b | bbaababbaaaaa=a >
bbaababbaaaaa -> a

# < a,b | bbaababbaaaba=a >
bbaababbaaaba -> a

# < a,b | bbaababbaabaa=a >
bbaababbaabaa -> a

# < a,b | bbaababbaabba=a >
bbaababbaabba -> a
bbaababbaaa -> aababbaabba

# < a,b | bbaababbabaaa=a >
bbaababbabaaa -> a

# < a,b | bbaababbababa=a >
bbaababbababa -> a

# < a,b | bbaababbabbaa=a >
bbaababbabbaa -> a
bbaababbaa -> ababbabbaa
bbaabaa -> ababbaa

# < a,b | bbaababbabbba=a >
bbaababbabbba -> a
bbaababbaba -> aababbabbba

# < a,b | bbaababbbaaaa=a >
bbaababbbaaaa -> a

# < a,b | bbaababbbaaba=a >
bbaababbbaaba -> a
bbaababa -> abbbaaba

# < a,b | bbaababbbabaa=a >
bbaababbbabaa -> a

# < a,b | bbaababbbbaaa=a >
bbaababbbbaaa -> a

# < a,b | bbaababbbbaba=a >
bbaababbbbaba -> a

# < a,b | bbaababbbbbba=a >
bbaababbbbbba -> a
bbaababbbba -> aababbbbbba
bbaababba -> aababbbba
bbaabaa -> aababba

# < a,b | bbaabbaaaaaaa=a >
bbaabbaaaaaaa -> a

# < a,b | bbaabbaaaaaba=a >
bbaabbaaaaaba -> a

# < a,b | bbaabbaaaabaa=a >
bbaabbaaaabaa -> a

# < a,b | bbaabbaaaabba=a >
bbaabbaaaabba -> a
bbaabbaaaaa -> aabbaaaabba

# < a,b | bbaabbaaabaaa=a >
bbaabbaaabaaa -> a

# < a,b | bbaabbaaababa=a >
bbaabbaaababa -> a

# < a,b | bbaabbaaabbaa=a >
bbaabbaaabbaa -> a
bbaabbaaaa -> abbaaabbaa

# < a,b | bbaabbaaabbba=a >
bbaabbaaabbba -> a
bbaabbaaaba -> aabbaaabbba

# < a,b | bbaabbaabaaaa=a >
bbaabbaabaaaa -> a

# < a,b | bbaabbaabaaba=a >
bbaabbaabaaba -> a

# < a,b | bbaabbaababaa=a >
bbaabbaababaa -> a

# < a,b | bbaabbaababba=a >
bbaabbaababba -> a
bbaabbaabaa -> aabbaababba

# < a,b | bbaabbaabbaaa=a >
bbaabbaabbaaa -> a

# < a,b | bbaabbaabbaba=a >
bbaabbaabbaba -> a

# < a,b | bbaabbaabbbaa=a >
bbaabbaabbbaa -> a
bbaabbaaba -> abbaabbbaa

# < a,b | bbaabbabaaaaa=a >
bbaabbabaaaaa -> a

# < a,b | bbaabbabaaaba=a >
bbaabbabaaaba -> a

# < a,b | bbaabbabaabaa=a >
bbaabbabaabaa -> a

# < a,b | bbaabbabaabba=a >
bbaabbabaabba -> a
bbaabbabaaa -> aabbabaabba

# < a,b | bbaabbababaaa=a >
bbaabbababaaa -> a

# < a,b | bbaabbabababa=a >
bbaabbabababa -> a

# < a,b | bbaabbababbaa=a >
bbaabbababbaa -> a
bbaabbabaa -> abbababbaa

# < a,b | bbaabbababbba=a >
bbaabbababbba -> a
bbaabbababa -> aabbababbba

# < a,b | bbaabbabbaaaa=a >
bbaabbabbaaaa -> a

# < a,b | bbaabbabbaaba=a >
bbaabbabbaaba -> a

# < a,b | bbaabbabbabaa=a >
bbaabbabbabaa -> a

# < a,b | bbaabbabbbaaa=a >
bbaabbabbbaaa -> a

# < a,b | bbaabbabbbaba=a >
bbaabbabbbaba -> a

# < a,b | bbaabbabbbbba=a >
bbaabbabbbbba -> a
bbaabbabbba -> aabbabbbbba
bbaabbaba -> aabbabbba

# < a,b | bbaabbbaaaaaa=a >
bbaabbbaaaaaa -> a

# < a,b | bbaabbbaaaaba=a >
bbaabbbaaaaba -> a

# < a,b | bbaabbbaaabaa=a >
bbaabbbaaabaa -> a

# < a,b | bbaabbbaaabba=a >
bbaabbbaaabba -> a
bbaabbbaaaa -> aabbbaaabba

# < a,b | bbaabbbaabaaa=a >
bbaabbbaabaaa -> a

# < a,b | bbaabbbaababa=a >
bbaabbbaababa -> a

# < a,b | bbaabbbaabbaa=a >
bbaabbbaabbaa -> a
bbaabbbaaa -> abbbaabbaa

# < a,b | bbaabbbaabbba=a >
bbaabbbaabbba -> a
bbaaba -> aabbba

# < a,b | bbaabbbabaaaa=a >
bbaabbbabaaaa -> a

# < a,b | bbaabbbabaaba=a >
bbaabbbabaaba -> a

# < a,b | bbaabbbababaa=a >
bbaabbbababaa -> a

# < a,b | bbaabbbababba=a >
bbaabbbababba -> a
bbaabbbabaa -> aabbbababba

# < a,b | bbaabbbabbaaa=a >
bbaabbbabbaaa -> a

# < a,b | bbaabbbabbaba=a >
bbaabbbabbaba -> a

# < a,b | bbaabbbabbbaa=a >
bbaabbbabbbaa -> a
bbaabbbaba -> abbbabbbaa

# < a,b | bbaabbbbaaaaa=a >
bbaabbbbaaaaa -> a

# < a,b | bbaabbbbaaaba=a >
bbaabbbbaaaba -> a

# < a,b | bbaabbbbaabaa=a >
bbaabbbbaabaa -> a

# < a,b | bbaabbbbaabba=a >
bbaabbbbaabba -> a
bbaabbbbaaa -> aabbbbaabba

# < a,b | bbaabbbbabaaa=a >
bbaabbbbabaaa -> a

# < a,b | bbaabbbbababa=a >
bbaabbbbababa -> a

# < a,b | bbaabbbbabbba=a >
bbaabbbbabbba -> a
bbaabbbbaba -> aabbbbabbba

# < a,b | bbaabbbbbaaaa=a >
bbaabbbbbaaaa -> a

# < a,b | bbaabbbbbaaba=a >
bbaabbbbbaaba -> a

# < a,b | bbaabbbbbabaa=a >
bbaabbbbbabaa -> a

# < a,b | bbaabbbbbbaaa=a >
bbaabbbbbbaaa -> a

# < a,b | bbaabbbbbbaba=a >
bbaabbbbbbaba -> a

# < a,b | bbaabbbbbbbba=a >
bbaabbbbbbbba -> a
bbaabbbbbba -> aabbbbbbbba
bbaabbbba -> aabbbbbba
bbaabba -> aabbbba
bbaaa -> aabba

# < a,b | bbabaaaaaaaaa=a >
bbabaaaaaaaaa -> a

# < a,b | bbabaaaaaaaba=a >
bbabaaaaaaaba -> a

# < a,b | bbabaaaaaabaa=a >
bbabaaaaaabaa -> a

# < a,b | bbabaaaaaabba=a >
bbabaaaaaabba -> a
bbabaaaaaaa -> abaaaaaabba

# < a,b | bbabaaaaabaaa=a >
bbabaaaaabaaa -> a

# < a,b | bbabaaaaababa=a >
bbabaaaaababa -> a

# < a,b | bbabaaaaabbaa=a >
bbabaaaaabbaa -> a

# < a,b | bbabaaaaabbba=a >
bbabaaaaabbba -> a
bbabaaaaaba -> abaaaaabbba

# < a,b | bbabaaaabaaaa=a >
bbabaaaabaaaa -> a

# < a,b | bbabaaaabaaba=a >
bbabaaaabaaba -> a

# < a,b | bbabaaaababaa=a >
bbabaaaababaa -> a

# < a,b | bbabaaaababba=a >
bbabaaaababba -> a
bbabaaaabaa -> abaaaababba

# < a,b | bbabaaaabbaaa=a >
bbabaaaabbaaa -> a

# < a,b | bbabaaaabbaba=a >
bbabaaaabbaba -> a
bbabaaaaa -> aaaabbaba

# < a,b | bbabaaaabbbaa=a >
bbabaaaabbbaa -> a

# < a,b | bbabaaaabbbba=a >
bbabaaaabbbba -> a
bbabaaaabba -> abaaaabbbba
bbabaaaaa -> abaaaabba

# < a,b | bbabaaabaaaaa=a >
bbabaaabaaaaa -> a

# < a,b | bbabaaabaaaba=a >
bbabaaabaaaba -> a

# < a,b | bbabaaabaabaa=a >
bbabaaabaabaa -> a

# < a,b | bbabaaabaabba=a >
bbabaaabaabba -> a
bbabaaabaaa -> abaaabaabba

# < a,b | bbabaaababaaa=a >
bbabaaababaaa -> a

# < a,b | bbabaaabababa=a >
bbabaaabababa -> a

# < a,b | bbabaaababbaa=a >
bbabaaababbaa -> a

# < a,b | bbabaaababbba=a >
bbabaaababbba -> a
bbabaaababa -> abaaababbba

# < a,b | bbabaaabbaaaa=a >
bbabaaabbaaaa -> a

# < a,b | bbabaaabbaaba=a >
bbabaaabbaaba -> a

# < a,b | bbabaaabbabaa=a >
bbabaaabbabaa -> a
bbabaaaa -> aabbabaa

# < a,b | bbabaaabbabba=a >
bbabaaabbabba -> a
bbabaaabbaa -> abaaabbabba

# < a,b | bbabaaabbbaaa=a >
bbabaaabbbaaa -> a

# < a,b | bbabaaabbbaba=a >
bbabaaabbbaba -> a
bbabaaaba -> aaabbbaba

# < a,b | bbabaaabbbbaa=a >
bbabaaabbbbaa -> a

# < a,b | bbabaaabbbbba=a >
bbabaaabbbbba -> a
bbabaaabbba -> abaaabbbbba
bbabaaaba -> abaaabbba

# < a,b | bbabaabaaaaaa=a >
bbabaabaaaaaa -> a

# < a,b | bbabaabaaaaba=a >
bbabaabaaaaba -> a

# < a,b | bbabaabaaabaa=a >
bbabaabaaabaa -> a

# < a,b | bbabaabaaabba=a >
bbabaabaaabba -> a
bbabaabaaaa -> abaabaaabba

# < a,b | bbabaabaabaaa=a >
bbabaabaabaaa -> a

# < a,b | bbabaabaababa=a >
bbabaabaababa -> a

# < a,b | bbabaabaabbaa=a >
bbabaabaabbaa -> a

# < a,b | bbabaabaabbba=a >
bbabaabaabbba -> a
bbabaabaaba -> abaabaabbba

# < a,b | bbabaababaaaa=a >
bbabaababaaaa -> a

# < a,b | bbabaababaaba=a >
bbabaababaaba -> a

# < a,b | bbabaabababaa=a >
bbabaabababaa -> a

# < a,b | bbabaabababba=a >
bbabaabababba -> a
bbabaababaa -> abaabababba

# < a,b | bbabaababbaaa=a >
bbabaababbaaa -> a

# < a,b | bbabaababbaba=a >
bbabaababbaba -> a
bbabaabaa -> aababbaba

# < a,b | bbabaababbbaa=a >
bbabaababbbaa -> a

# < a,b | bbabaababbbba=a >
bbabaababbbba -> a
bbabaababba -> abaababbbba
bbabaabaa -> abaababba

# < a,b | bbabaabbaaaaa=a >
bbabaabbaaaaa -> a

# < a,b | bbabaabbaaaba=a >
bbabaabbaaaba -> a

# < a,b | bbabaabbaabaa=a >
bbabaabbaabaa -> a

# < a,b | bbabaabbaabba=a >
bbabaabbaabba -> a
bbabaabbaaa -> abaabbaabba

# < a,b | bbabaabbabaaa=a >
bbabaabbabaaa -> a

# < a,b | bbabaabbababa=a >
bbabaabbababa -> a

# < a,b | bbabaabbabbaa=a >
bbabaabbabbaa -> a

# < a,b | bbabaabbbaaaa=a >
bbabaabbbaaaa -> a

# < a,b | bbabaabbbaaba=a >
bbabaabbbaaba -> a

# < a,b | bbabaabbbabaa=a >
bbabaabbbabaa -> a
bbabaaba -> abbbabaa

# < a,b | bbabaabbbabba=a >
bbabaabbbabba -> a
bbabaabbbaa -> abaabbbabba

# < a,b | bbabaabbbbaaa=a >
bbabaabbbbaaa -> a

# < a,b | bbabaabbbbbaa=a >
bbabaabbbbbaa -> a

# < a,b | bbabaabbbbbba=a >
bbabaabbbbbba -> a
bbabaabbbba -> abaabbbbbba
bbabaabba -> abaabbbba
bbabaaa -> abaabba

# < a,b | bbababaaaaaaa=a >
bbababaaaaaaa -> a

# < a,b | bbababaaaaaba=a >
bbababaaaaaba -> a

# < a,b | bbababaaaabaa=a >
bbababaaaabaa -> a

# < a,b | bbababaaaabba=a >
bbababaaaabba -> a
bbababaaaaa -> ababaaaabba

# < a,b | bbababaaabaaa=a >
bbababaaabaaa -> a

# < a,b | bbababaaababa=a >
bbababaaababa -> a

# < a,b | bbababaaabbaa=a >
bbababaaabbaa -> a

# < a,b | bbababaaabbba=a >
bbababaaabbba -> a
bbababaaaba -> ababaaabbba

# < a,b | bbababaabaaaa=a >
bbababaabaaaa -> a

# < a,b | bbababaabaaba=a >
bbababaabaaba -> a

# < a,b | bbababaababaa=a >
bbababaababaa -> a

# < a,b | bbababaababba=a >
bbababaababba -> a
bbababaabaa -> ababaababba

# < a,b | bbababaabbaaa=a >
bbababaabbaaa -> a

# < a,b | bbababaabbaba=a >
bbababaabbaba -> a
bbababaaa -> abaabbaba

# < a,b | bbababaabbbaa=a >
bbababaabbbaa -> a

# < a,b | bbababaabbbba=a >
bbababaabbbba -> a
bbababaabba -> ababaabbbba
bbababaaa -> ababaabba

# < a,b | bbabababaaaaa=a >
bbabababaaaaa -> a

# < a,b | bbabababaaaba=a >
bbabababaaaba -> a

# < a,b | bbabababaabaa=a >
bbabababaabaa -> a

# < a,b | bbabababaabba=a >
bbabababaabba -> a
bbabababaaa -> abababaabba

# < a,b | bbababababaaa=a >
bbababababaaa -> a

# < a,b | bbabababababa=a >
bbabababababa -> a

# < a,b | bbababababbaa=a >
bbababababbaa -> a

# < a,b | bbababababbba=a >
bbababababbba -> a
bbababababa -> ababababbba

# < a,b | bbabababbaaaa=a >
bbabababbaaaa -> a

# < a,b | bbabababbaaba=a >
bbabababbaaba -> a

# < a,b | bbabababbabaa=a >
bbabababbabaa -> a

# < a,b | bbabababbabba=a >
bbabababbabba -> a
bbabababbaa -> abababbabba

# < a,b | bbabababbbaaa=a >
bbabababbbaaa -> a

# < a,b | bbabababbbaba=a >
bbabababbbaba -> a
bbabababa -> ababbbaba

# < a,b | bbabababbbbaa=a >
bbabababbbbaa -> a

# < a,b | bbabababbbbba=a >
bbabababbbbba -> a
bbabababbba -> abababbbbba
bbabababa -> abababbba

# < a,b | bbababbaaaaaa=a >
bbababbaaaaaa -> a

# < a,b | bbababbaaaaba=a >
bbababbaaaaba -> a

# < a,b | bbababbaaabaa=a >
bbababbaaabaa -> a

# < a,b | bbababbaaabba=a >
bbababbaaabba -> a
bbababbaaaa -> ababbaaabba

# < a,b | bbababbaabaaa=a >
bbababbaabaaa -> a

# < a,b | bbababbaababa=a >
bbababbaababa -> a

# < a,b | bbababbaabbaa=a >
bbababbaabbaa -> a

# < a,b | bbababbaabbba=a >
bbababbaabbba -> a
bbababbaaba -> ababbaabbba

# < a,b | bbababbabaaaa=a >
bbababbabaaaa -> a

# < a,b | bbababbabaaba=a >
bbababbabaaba -> a

# < a,b | bbababbababaa=a >
bbababbababaa -> a

# < a,b | bbababbababba=a >
bbababbababba -> a
bbabaa -> ababba

# < a,b | bbababbabbaaa=a >
bbababbabbaaa -> a

# < a,b | bbababbabbaba=a >
bbababbabbaba -> a
bbababbaa -> abbabbaba

# < a,b | bbababbabbbaa=a >
bbababbabbbaa -> a

# < a,b | bbababbabbbba=a >
bbababbabbbba -> a
bbababbabba -> ababbabbbba
bbababbaa -> ababbabba

# < a,b | bbababbbaaaaa=a >
bbababbbaaaaa -> a

# < a,b | bbababbbaaaba=a >
bbababbbaaaba -> a

# < a,b | bbababbbaabaa=a >
bbababbbaabaa -> a

# < a,b | bbababbbaabba=a >
bbababbbaabba -> a
bbababbbaaa -> ababbbaabba

# < a,b | bbababbbabaaa=a >
bbababbbabaaa -> a

# < a,b | bbababbbababa=a >
bbababbbababa -> a

# < a,b | bbababbbabbaa=a >
bbababbbabbaa -> a

# < a,b | bbababbbbaaaa=a >
bbababbbbaaaa -> a

# < a,b | bbababbbbaaba=a >
bbababbbbaaba -> a

# < a,b | bbababbbbabaa=a >
bbababbbbabaa -> a

# < a,b | bbababbbbabba=a >
bbababbbbabba -> a
bbababbbbaa -> ababbbbabba

# < a,b | bbababbbbbaaa=a >
bbababbbbbaaa -> a

# < a,b | bbababbbbbbaa=a >
bbababbbbbbaa -> a

# < a,b | bbababbbbbbba=a >
bbababbbbbbba -> a
bbababbbbba -> ababbbbbbba
bbababbba -> ababbbbba
bbababa -> ababbba

# < a,b | bbabbaaaaaaaa=a >
bbabbaaaaaaaa -> a

# < a,b | bbabbaaaaaaba=a >
bbabbaaaaaaba -> a

# < a,b | bbabbaaaaabaa=a >
bbabbaaaaabaa -> a

# < a,b | bbabbaaaaabba=a >
bbabbaaaaabba -> a
bbabbaaaaaa -> abbaaaaabba

# < a,b | bbabbaaaabaaa=a >
bbabbaaaabaaa -> a

# < a,b | bbabbaaaababa=a >
bbabbaaaababa -> a

# < a,b | bbabbaaaabbaa=a >
bbabbaaaabbaa -> a

# < a,b | bbabbaaaabbba=a >
bbabbaaaabbba -> a
bbabbaaaaba -> abbaaaabbba

# < a,b | bbabbaaabaaaa=a >
bbabbaaabaaaa -> a

# < a,b | bbabbaaabaaba=a >
bbabbaaabaaba -> a

# < a,b | bbabbaaababaa=a >
bbabbaaababaa -> a

# < a,b | bbabbaaababba=a >
bbabbaaababba -> a
bbabbaaabaa -> abbaaababba

# < a,b | bbabbaaabbaaa=a >
bbabbaaabbaaa -> a

# < a,b | bbabbaaabbaba=a >
bbabbaaabbaba -> a

# < a,b | bbabbaaabbbaa=a >
bbabbaaabbbaa -> a

# < a,b | bbabbaaabbbba=a >
bbabbaaabbbba -> a
bbabbaaabba -> abbaaabbbba
bbabbaaaa -> abbaaabba

# < a,b | bbabbaabaaaaa=a >
bbabbaabaaaaa -> a

# < a,b | bbabbaabaaaba=a >
bbabbaabaaaba -> a

# < a,b | bbabbaabaabaa=a >
bbabbaabaabaa -> a

# < a,b | bbabbaabaabba=a >
bbabbaabaabba -> a
bbabbaabaaa -> abbaabaabba

# < a,b | bbabbaababaaa=a >
bbabbaababaaa -> a

# < a,b | bbabbaabababa=a >
bbabbaabababa -> a

# < a,b | bbabbaababbaa=a >
bbabbaababbaa -> a

# < a,b | bbabbaababbba=a >
bbabbaababbba -> a
bbabbaababa -> abbaababbba

# < a,b | bbabbaabbaaaa=a >
bbabbaabbaaaa -> a

# < a,b | bbabbaabbaaba=a >
bbabbaabbaaba -> a

# < a,b | bbabbaabbabaa=a >
bbabbaabbabaa -> a

# < a,b | bbabbaabbabba=a >
bbabbaabbabba -> a
bbabbaabbaa -> abbaabbabba
bbabbaaa -> aabbabba

# < a,b | bbabbaabbbaaa=a >
bbabbaabbbaaa -> a

# < a,b | bbabbaabbbaba=a >
bbabbaabbbaba -> a

# < a,b | bbabbaabbbbaa=a >
bbabbaabbbbaa -> a

# < a,b | bbabbaabbbbba=a >
bbabbaabbbbba -> a
bbabbaabbba -> abbaabbbbba
bbabbaaba -> abbaabbba

# < a,b | bbabbabaaaaaa=a >
bbabbabaaaaaa -> a

# < a,b | bbabbabaaaaba=a >
bbabbabaaaaba -> a

# < a,b | bbabbabaaabaa=a >
bbabbabaaabaa -> a

# < a,b | bbabbabaaabba=a >
bbabbabaaabba -> a
bbabbabaaaa -> abbabaaabba

# < a,b | bbabbabaabaaa=a >
bbabbabaabaaa -> a

# < a,b | bbabbabaababa=a >
bbabbabaababa -> a

# < a,b | bbabbabaabbaa=a >
bbabbabaabbaa -> a

# < a,b | bbabbabaabbba=a >
bbabbabaabbba -> a
bbabbabaaba -> abbabaabbba

# < a,b | bbabbababaaaa=a >
bbabbababaaaa -> a

# < a,b | bbabbababaaba=a >
bbabbababaaba -> a

# < a,b | bbabbabababaa=a >
bbabbabababaa -> a

# < a,b | bbabbabababba=a >
bbabbabababba -> a
bbabbababaa -> abbabababba

# < a,b | bbabbababbaaa=a >
bbabbababbaaa -> a

# < a,b | bbabbababbaba=a >
bbabbababbaba -> a

# < a,b | bbabbababbbaa=a >
bbabbababbbaa -> a

# < a,b | bbabbababbbba=a >
bbabbababbbba -> a
bbabbababba -> abbababbbba
bbabbabaa -> abbababba

# < a,b | bbabbabbaaaaa=a >
bbabbabbaaaaa -> a

# < a,b | bbabbabbaaaba=a >
bbabbabbaaaba -> a

# < a,b | bbabbabbaabaa=a >
bbabbabbaabaa -> a

# < a,b | bbabbabbaabba=a >
bbabbabbaabba -> a
bbabbabbaaa -> abbabbaabba

# < a,b | bbabbabbabaaa=a >
bbabbabbabaaa -> a

# < a,b | bbabbabbababa=a >
bbabbabbababa -> a

# < a,b | bbabbabbabbaa=a >
bbabbabbabbaa -> a

# < a,b | bbabbabbabbba=a >
bbabbabbabbba -> a
bbabbabbaba -> abbabbabbba

# < a,b | bbabbabbbaaaa=a >
bbabbabbbaaaa -> a

# < a,b | bbabbabbbaaba=a >
bbabbabbbaaba -> a

# < a,b | bbabbabbbabaa=a >
bbabbabbbabaa -> a

# < a,b | bbabbabbbabba=a >
bbabbabbbabba -> a
bbabbabbbaa -> abbabbbabba
bbabbaba -> abbbabba

# < a,b | bbabbabbbbaaa=a >
bbabbabbbbaaa -> a

# < a,b | bbabbabbbbaba=a >
bbabbabbbbaba -> a

# < a,b | bbabbabbbbbaa=a >
bbabbabbbbbaa -> a

# < a,b | bbabbbaaaaaaa=a >
bbabbbaaaaaaa -> a

# < a,b | bbabbbaaaaaba=a >
bbabbbaaaaaba -> a

# < a,b | bbabbbaaaabaa=a >
bbabbbaaaabaa -> a

# < a,b | bbabbbaaaabba=a >
bbabbbaaaabba -> a
bbabbbaaaaa -> abbbaaaabba

# < a,b | bbabbbaaabaaa=a >
bbabbbaaabaaa -> a

# < a,b | bbabbbaaababa=a >
bbabbbaaababa -> a

# < a,b | bbabbbaaabbaa=a >
bbabbbaaabbaa -> a

# < a,b | bbabbbaaabbba=a >
bbabbbaaabbba -> a
bbabbbaaaba -> abbbaaabbba

# < a,b | bbabbbaabaaaa=a >
bbabbbaabaaaa -> a

# < a,b | bbabbbaabaaba=a >
bbabbbaabaaba -> a

# < a,b | bbabbbaababaa=a >
bbabbbaababaa -> a

# < a,b | bbabbbaababba=a >
bbabbbaababba -> a
bbabbbaabaa -> abbbaababba

# < a,b | bbabbbaabbaaa=a >
bbabbbaabbaaa -> a

# < a,b | bbabbbaabbaba=a >
bbabbbaabbaba -> a

# < a,b | bbabbbaabbbaa=a >
bbabbbaabbbaa -> a

# < a,b | bbabbbaabbbba=a >
bbabbbaabbbba -> a
bbabbbaabba -> abbbaabbbba
bbabbbaaa -> abbbaabba

# < a,b | bbabbbabaaaaa=a >
bbabbbabaaaaa -> a

# < a,b | bbabbbabaaaba=a >
bbabbbabaaaba -> a

# < a,b | bbabbbabaabaa=a >
bbabbbabaabaa -> a

# < a,b | bbabbbabaabba=a >
bbabbbabaabba -> a
bbabbbabaaa -> abbbabaabba

# < a,b | bbabbbababaaa=a >
bbabbbababaaa -> a

# < a,b | bbabbbabababa=a >
bbabbbabababa -> a

# < a,b | bbabbbababbaa=a >
bbabbbababbaa -> a

# < a,b | bbabbbababbba=a >
bbabbbababbba -> a
bbabbbababa -> abbbababbba

# < a,b | bbabbbabbaaaa=a >
bbabbbabbaaaa -> a

# < a,b | bbabbbabbaaba=a >
bbabbbabbaaba -> a

# < a,b | bbabbbabbabaa=a >
bbabbbabbabaa -> a

# < a,b | bbabbbabbabba=a >
bbabbbabbabba -> a
bbabbbabbaa -> abbbabbabba

# < a,b | bbabbbabbbaaa=a >
bbabbbabbbaaa -> a

# < a,b | bbabbbabbbaba=a >
bbabbbabbbaba -> a

# < a,b | bbabbbabbbbaa=a >
bbabbbabbbbaa -> a

# < a,b | bbabbbbaaaaaa=a >
bbabbbbaaaaaa -> a

# < a,b | bbabbbbaaaaba=a >
bbabbbbaaaaba -> a

# < a,b | bbabbbbaaabaa=a >
bbabbbbaaabaa -> a

# < a,b | bbabbbbaaabba=a >
bbabbbbaaabba -> a
bbabbbbaaaa -> abbbbaaabba

# < a,b | bbabbbbaabaaa=a >
bbabbbbaabaaa -> a

# < a,b | bbabbbbaababa=a >
bbabbbbaababa -> a

# < a,b | bbabbbbaabbaa=a >
bbabbbbaabbaa -> a

# < a,b | bbabbbbaabbba=a >
bbabbbbaabbba -> a
bbabbbbaaba -> abbbbaabbba

# < a,b | bbabbbbabaaaa=a >
bbabbbbabaaaa -> a

# < a,b | bbabbbbabaaba=a >
bbabbbbabaaba -> a

# < a,b | bbabbbbababaa=a >
bbabbbbababaa -> a

# < a,b | bbabbbbababba=a >
bbabbbbababba -> a
bbabbbbabaa -> abbbbababba

# < a,b | bbabbbbabbaaa=a >
bbabbbbabbaaa -> a

# < a,b | bbabbbbabbaba=a >
bbabbbbabbaba -> a

# < a,b | bbabbbbabbbaa=a >
bbabbbbabbbaa -> a

# < a,b | bbabbbbabbbba=a >
bbabbbbabbbba -> a
bbabba -> abbbba
bbaa -> abba

# < a,b | bbabbbbbaaaaa=a >
bbabbbbbaaaaa -> a

# < a,b | bbabbbbbaaaba=a >
bbabbbbbaaaba -> a

# < a,b | bbabbbbbaabaa=a >
bbabbbbbaabaa -> a

# < a,b | bbabbbbbaabba=a >
bbabbbbbaabba -> a
bbabbbbbaaa -> abbbbbaabba

# < a,b | bbabbbbbabaaa=a >
bbabbbbbabaaa -> a

# < a,b | bbabbbbbababa=a >
bbabbbbbababa -> a

# < a,b | bbabbbbbabbaa=a >
bbabbbbbabbaa -> a

# < a,b | bbabbbbbabbba=a >
bbabbbbbabbba -> a
bbabbbbbaba -> abbbbbabbba

# < a,b | bbabbbbbbaaaa=a >
bbabbbbbbaaaa -> a

# < a,b | bbabbbbbbaaba=a >
bbabbbbbbaaba -> a

# < a,b | bbabbbbbbabaa=a >
bbabbbbbbabaa -> a

# < a,b | bbabbbbbbabba=a >
bbabbbbbbabba -> a
bbabbbbbbaa -> abbbbbbabba

# < a,b | bbabbbbbbbaaa=a >
bbabbbbbbbaaa -> a

# < a,b | bbabbbbbbbaba=a >
bbabbbbbbbaba -> a

# < a,b | bbabbbbbbbbaa=a >
bbabbbbbbbbaa -> a

# < a,b | bbabbbbbbbbba=a >
bbabbbbbbbbba -> a
bbabbbbbbba -> abbbbbbbbba
bbabbbbba -> abbbbbbba
bbabbba -> abbbbba
bbaba -> abbba

# < a,b | bbbaaaaaaaaaa=a >
bbbaaaaaaaaaa -> a

# < a,b | bbbaaaaaaaaba=a >
bbbaaaaaaaaba -> a

# < a,b | bbbaaaaaaabaa=a >
bbbaaaaaaabaa -> a

# < a,b | bbbaaaaaaabba=a >
bbbaaaaaaabba -> a

# < a,b | bbbaaaaaabaaa=a >
bbbaaaaaabaaa -> a

# < a,b | bbbaaaaaababa=a >
bbbaaaaaababa -> a

# < a,b | bbbaaaaaabbaa=a >
bbbaaaaaabbaa -> a

# < a,b | bbbaaaaaabbba=a >
bbbaaaaaabbba -> a
bbbaaaaaaa -> aaaaaabbba

# < a,b | bbbaaaaabaaaa=a >
bbbaaaaabaaaa -> a

# < a,b | bbbaaaaabaaba=a >
bbbaaaaabaaba -> a

# < a,b | bbbaaaaababaa=a >
bbbaaaaababaa -> a

# < a,b | bbbaaaaababba=a >
bbbaaaaababba -> a

# < a,b | bbbaaaaabbaaa=a >
bbbaaaaabbaaa -> a

# < a,b | bbbaaaaabbaba=a >
bbbaaaaabbaba -> a

# < a,b | bbbaaaaabbbaa=a >
bbbaaaaabbbaa -> a
bbbaaaaaa -> aaaabbbaa

# < a,b | bbbaaaaabbbba=a >
bbbaaaaabbbba -> a
bbbaaaaaba -> aaaaabbbba

# < a,b | bbbaaaabaaaaa=a >
bbbaaaabaaaaa -> a

# < a,b | bbbaaaabaaaba=a >
bbbaaaabaaaba -> a

# < a,b | bbbaaaabaabaa=a >
bbbaaaabaabaa -> a

# < a,b | bbbaaaabaabba=a >
bbbaaaabaabba -> a

# < a,b | bbbaaaababaaa=a >
bbbaaaababaaa -> a

# < a,b | bbbaaaabababa=a >
bbbaaaabababa -> a

# < a,b | bbbaaaababbaa=a >
bbbaaaababbaa -> a

# < a,b | bbbaaaababbba=a >
bbbaaaababbba -> a
bbbaaaabaa -> aaaababbba

# < a,b | bbbaaaabbaaaa=a >
bbbaaaabbaaaa -> a

# < a,b | bbbaaaabbaaba=a >
bbbaaaabbaaba -> a

# < a,b | bbbaaaabbabaa=a >
bbbaaaabbabaa -> a

# < a,b | bbbaaaabbabba=a >
bbbaaaabbabba -> a

# < a,b | bbbaaaabbbaaa=a >
bbbaaaabbbaaa -> a
bbbaaaaa -> aabbbaaa

# < a,b | bbbaaaabbbaba=a >
bbbaaaabbbaba -> a

# < a,b | bbbaaaabbbbaa=a >
bbbaaaabbbbaa -> a
bbbaaaaba -> aaabbbbaa

# < a,b | bbbaaaabbbbba=a >
bbbaaaabbbbba -> a
bbbaaaabba -> aaaabbbbba

# < a,b | bbbaaabaaaaaa=a >
bbbaaabaaaaaa -> a

# < a,b | bbbaaabaaaaba=a >
bbbaaabaaaaba -> a

# < a,b | bbbaaabaaabaa=a >
bbbaaabaaabaa -> a

# < a,b | bbbaaabaaabba=a >
bbbaaabaaabba -> a

# < a,b | bbbaaabaabaaa=a >
bbbaaabaabaaa -> a

# < a,b | bbbaaabaababa=a >
bbbaaabaababa -> a

# < a,b | bbbaaabaabbaa=a >
bbbaaabaabbaa -> a

# < a,b | bbbaaabaabbba=a >
bbbaaabaabbba -> a
bbbaaabaaa -> aaabaabbba

# < a,b | bbbaaababaaaa=a >
bbbaaababaaaa -> a

# < a,b | bbbaaababaaba=a >
bbbaaababaaba -> a

# < a,b | bbbaaabababaa=a >
bbbaaabababaa -> a

# < a,b | bbbaaabababba=a >
bbbaaabababba -> a

# < a,b | bbbaaababbaaa=a >
bbbaaababbaaa -> a

# < a,b | bbbaaababbaba=a >
bbbaaababbaba -> a

# < a,b | bbbaaababbbaa=a >
bbbaaababbbaa -> a
bbbaaabaa -> aababbbaa

# < a,b | bbbaaababbbba=a >
bbbaaababbbba -> a
bbbaaababa -> aaababbbba

# < a,b | bbbaaabbaaaaa=a >
bbbaaabbaaaaa -> a

# < a,b | bbbaaabbaaaba=a >
bbbaaabbaaaba -> a

# < a,b | bbbaaabbaabaa=a >
bbbaaabbaabaa -> a

# < a,b | bbbaaabbaabba=a >
bbbaaabbaabba -> a

# < a,b | bbbaaabbabaaa=a >
bbbaaabbabaaa -> a

# < a,b | bbbaaabbababa=a >
bbbaaabbababa -> a

# < a,b | bbbaaabbabbaa=a >
bbbaaabbabbaa -> a

# < a,b | bbbaaabbabbba=a >
bbbaaabbabbba -> a
bbbaaabbaa -> aaabbabbba

# < a,b | bbbaaabbbaaaa=a >
bbbaaabbbaaaa -> a

# < a,b | bbbaaabbbaaba=a >
bbbaaabbbaaba -> a

# < a,b | bbbaaabbbabaa=a >
bbbaaabbbabaa -> a

# < a,b | bbbaaabbbabba=a >
bbbaaabbbabba -> a

# < a,b | bbbaaabbbbaaa=a >
bbbaaabbbbaaa -> a
bbbaaaba -> abbbbaaa

# < a,b | bbbaaabbbbaba=a >
bbbaaabbbbaba -> a

# < a,b | bbbaaabbbbbaa=a >
bbbaaabbbbbaa -> a
bbbaaabba -> aabbbbbaa

# < a,b | bbbaaabbbbbba=a >
bbbaaabbbbbba -> a
bbbaaabbba -> aaabbbbbba
bbbaaaa -> aaabbba

# < a,b | bbbaabaaaaaaa=a >
bbbaabaaaaaaa -> a

# < a,b | bbbaabaaaaaba=a >
bbbaabaaaaaba -> a

# < a,b | bbbaabaaaabaa=a >
bbbaabaaaabaa -> a

# < a,b | bbbaabaaaabba=a >
bbbaabaaaabba -> a

# < a,b | bbbaabaaabaaa=a >
bbbaabaaabaaa -> a

# < a,b | bbbaabaaababa=a >
bbbaabaaababa -> a

# < a,b | bbbaabaaabbaa=a >
bbbaabaaabbaa -> a

# < a,b | bbbaabaaabbba=a >
bbbaabaaabbba -> a
bbbaabaaaa -> aabaaabbba

# < a,b | bbbaabaabaaaa=a >
bbbaabaabaaaa -> a

# < a,b | bbbaabaabaaba=a >
bbbaabaabaaba -> a

# < a,b | bbbaabaababaa=a >
bbbaabaababaa -> a

# < a,b | bbbaabaababba=a >
bbbaabaababba -> a

# < a,b | bbbaabaabbaaa=a >
bbbaabaabbaaa -> a

# < a,b | bbbaabaabbaba=a >
bbbaabaabbaba -> a

# < a,b | bbbaabaabbbaa=a >
bbbaabaabbbaa -> a
bbbaabaaa -> abaabbbaa

# < a,b | bbbaabaabbbba=a >
bbbaabaabbbba -> a
bbbaabaaba -> aabaabbbba

# < a,b | bbbaababaaaaa=a >
bbbaababaaaaa -> a

# < a,b | bbbaababaaaba=a >
bbbaababaaaba -> a

# < a,b | bbbaababaabaa=a >
bbbaababaabaa -> a

# < a,b | bbbaababaabba=a >
bbbaababaabba -> a

# < a,b | bbbaabababaaa=a >
bbbaabababaaa -> a

# < a,b | bbbaababababa=a >
bbbaababababa -> a

# < a,b | bbbaabababbaa=a >
bbbaabababbaa -> a

# < a,b | bbbaabababbba=a >
bbbaabababbba -> a
bbbaababaa -> aabababbba

# < a,b | bbbaababbaaaa=a >
bbbaababbaaaa -> a

# < a,b | bbbaababbaaba=a >
bbbaababbaaba -> a

# < a,b | bbbaababbabaa=a >
bbbaababbabaa -> a

# < a,b | bbbaababbabba=a >
bbbaababbabba -> a

# < a,b | bbbaababbbaaa=a >
bbbaababbbaaa -> a

# < a,b | bbbaababbbaba=a >
bbbaababbbaba -> a

# < a,b | bbbaababbbbaa=a >
bbbaababbbbaa -> a
bbbaababa -> ababbbbaa

# < a,b | bbbaababbbbba=a >
bbbaababbbbba -> a
bbbaababba -> aababbbbba

# < a,b | bbbaabbaaaaaa=a >
bbbaabbaaaaaa -> a

# < a,b | bbbaabbaaaaba=a >
bbbaabbaaaaba -> a

# < a,b | bbbaabbaaabaa=a >
bbbaabbaaabaa -> a

# < a,b | bbbaabbaaabba=a >
bbbaabbaaabba -> a

# < a,b | bbbaabbaabaaa=a >
bbbaabbaabaaa -> a

# < a,b | bbbaabbaababa=a >
bbbaabbaababa -> a

# < a,b | bbbaabbaabbaa=a >
bbbaabbaabbaa -> a

# < a,b | bbbaabbaabbba=a >
bbbaabbaabbba -> a
bbbaabbaaa -> aabbaabbba

# < a,b | bbbaabbabaaaa=a >
bbbaabbabaaaa -> a

# < a,b | bbbaabbabaaba=a >
bbbaabbabaaba -> a

# < a,b | bbbaabbababaa=a >
bbbaabbababaa -> a

# < a,b | bbbaabbababba=a >
bbbaabbababba -> a

# < a,b | bbbaabbabbaaa=a >
bbbaabbabbaaa -> a

# < a,b | bbbaabbabbaba=a >
bbbaabbabbaba -> a

# < a,b | bbbaabbabbbaa=a >
bbbaabbabbbaa -> a
bbbaabbaa -> abbabbbaa

# < a,b | bbbaabbabbbba=a >
bbbaabbabbbba -> a
bbbaabbaba -> aabbabbbba

# < a,b | bbbaabbbaaaaa=a >
bbbaabbbaaaaa -> a

# < a,b | bbbaabbbaaaba=a >
bbbaabbbaaaba -> a

# < a,b | bbbaabbbaabaa=a >
bbbaabbbaabaa -> a

# < a,b | bbbaabbbaabba=a >
bbbaabbbaabba -> a

# < a,b | bbbaabbbabaaa=a >
bbbaabbbabaaa -> a

# < a,b | bbbaabbbababa=a >
bbbaabbbababa -> a

# < a,b | bbbaabbbabbaa=a >
bbbaabbbabbaa -> a

# < a,b | bbbaabbbbaaaa=a >
bbbaabbbbaaaa -> a

# < a,b | bbbaabbbbaaba=a >
bbbaabbbbaaba -> a

# < a,b | bbbaabbbbabaa=a >
bbbaabbbbabaa -> a

# < a,b | bbbaabbbbabba=a >
bbbaabbbbabba -> a

# < a,b | bbbaabbbbbaaa=a >
bbbaabbbbbaaa -> a

# < a,b | bbbaabbbbbaba=a >
bbbaabbbbbaba -> a

# < a,b | bbbaabbbbbbba=a >
bbbaabbbbbbba -> a
bbbaabbbba -> aabbbbbbba
bbbaaba -> aabbbba

# < a,b | bbbabaaaaaaaa=a >
bbbabaaaaaaaa -> a

# < a,b | bbbabaaaaaaba=a >
bbbabaaaaaaba -> a

# < a,b | bbbabaaaaabaa=a >
bbbabaaaaabaa -> a

# < a,b | bbbabaaaaabba=a >
bbbabaaaaabba -> a

# < a,b | bbbabaaaabaaa=a >
bbbabaaaabaaa -> a

# < a,b | bbbabaaaababa=a >
bbbabaaaababa -> a

# < a,b | bbbabaaaabbaa=a >
bbbabaaaabbaa -> a

# < a,b | bbbabaaaabbba=a >
bbbabaaaabbba -> a
bbbabaaaaa -> abaaaabbba

# < a,b | bbbabaaabaaaa=a >
bbbabaaabaaaa -> a

# < a,b | bbbabaaabaaba=a >
bbbabaaabaaba -> a

# < a,b | bbbabaaababaa=a >
bbbabaaababaa -> a

# < a,b | bbbabaaababba=a >
bbbabaaababba -> a

# < a,b | bbbabaaabbaaa=a >
bbbabaaabbaaa -> a

# < a,b | bbbabaaabbaba=a >
bbbabaaabbaba -> a

# < a,b | bbbabaaabbbaa=a >
bbbabaaabbbaa -> a

# < a,b | bbbabaaabbbba=a >
bbbabaaabbbba -> a
bbbabaaaba -> abaaabbbba

# < a,b | bbbabaabaaaaa=a >
bbbabaabaaaaa -> a

# < a,b | bbbabaabaaaba=a >
bbbabaabaaaba -> a

# < a,b | bbbabaabaabaa=a >
bbbabaabaabaa -> a

# < a,b | bbbabaabaabba=a >
bbbabaabaabba -> a

# < a,b | bbbabaababaaa=a >
bbbabaababaaa -> a

# < a,b | bbbabaabababa=a >
bbbabaabababa -> a

# < a,b | bbbabaababbaa=a >
bbbabaababbaa -> a

# < a,b | bbbabaababbba=a >
bbbabaababbba -> a
bbbabaabaa -> abaababbba

# < a,b | bbbabaabbaaaa=a >
bbbabaabbaaaa -> a

# < a,b | bbbabaabbaaba=a >
bbbabaabbaaba -> a

# < a,b | bbbabaabbabaa=a >
bbbabaabbabaa -> a

# < a,b | bbbabaabbabba=a >
bbbabaabbabba -> a

# < a,b | bbbabaabbbaaa=a >
bbbabaabbbaaa -> a

# < a,b | bbbabaabbbaba=a >
bbbabaabbbaba -> a
bbbabaaa -> aabbbaba

# < a,b | bbbabaabbbbaa=a >
bbbabaabbbbaa -> a

# < a,b | bbbabaabbbbba=a >
bbbabaabbbbba -> a
bbbabaabba -> abaabbbbba

# < a,b | bbbababaaaaaa=a >
bbbababaaaaaa -> a

# < a,b | bbbababaaaaba=a >
bbbababaaaaba -> a

# < a,b | bbbababaaabaa=a >
bbbababaaabaa -> a

# < a,b | bbbababaaabba=a >
bbbababaaabba -> a

# < a,b | bbbababaabaaa=a >
bbbababaabaaa -> a

# < a,b | bbbababaababa=a >
bbbababaababa -> a

# < a,b | bbbababaabbaa=a >
bbbababaabbaa -> a

# < a,b | bbbababaabbba=a >
bbbababaabbba -> a
bbbababaaa -> ababaabbba

# < a,b | bbbabababaaaa=a >
bbbabababaaaa -> a

# < a,b | bbbabababaaba=a >
bbbabababaaba -> a

# < a,b | bbbababababaa=a >
bbbababababaa -> a

# < a,b | bbbababababba=a >
bbbababababba -> a

# < a,b | bbbabababbaaa=a >
bbbabababbaaa -> a

# < a,b | bbbabababbaba=a >
bbbabababbaba -> a

# < a,b | bbbabababbbaa=a >
bbbabababbbaa -> a

# < a,b | bbbabababbbba=a >
bbbabababbbba -> a
bbbabababa -> abababbbba

# < a,b | bbbababbaaaaa=a >
bbbababbaaaaa -> a

# < a,b | bbbababbaaaba=a >
bbbababbaaaba -> a

# < a,b | bbbababbaabaa=a >
bbbababbaabaa -> a

# < a,b | bbbababbaabba=a >
bbbababbaabba -> a

# < a,b | bbbababbabaaa=a >
bbbababbabaaa -> a

# < a,b | bbbababbababa=a >
bbbababbababa -> a

# < a,b | bbbababbabbaa=a >
bbbababbabbaa -> a

# < a,b | bbbababbabbba=a >
bbbababbabbba -> a
bbbababbaa -> ababbabbba

# < a,b | bbbababbbaaaa=a >
bbbababbbaaaa -> a

# < a,b | bbbababbbaaba=a >
bbbababbbaaba -> a

# < a,b | bbbababbbabaa=a >
bbbababbbabaa -> a

# < a,b | bbbababbbabba=a >
bbbababbbabba -> a

# < a,b | bbbababbbbaaa=a >
bbbababbbbaaa -> a

# < a,b | bbbababbbbaba=a >
bbbababbbbaba -> a
bbbababa -> abbbbaba

# < a,b | bbbababbbbbaa=a >
bbbababbbbbaa -> a

# < a,b | bbbababbbbbba=a >
bbbababbbbbba -> a
bbbababbba -> ababbbbbba
bbbabaa -> ababbba

# < a,b | bbbabbaaaaaaa=a >
bbbabbaaaaaaa -> a

# < a,b | bbbabbaaaaaba=a >
bbbabbaaaaaba -> a

# < a,b | bbbabbaaaabaa=a >
bbbabbaaaabaa -> a

# < a,b | bbbabbaaaabba=a >
bbbabbaaaabba -> a

# < a,b | bbbabbaaabaaa=a >
bbbabbaaabaaa -> a

# < a,b | bbbabbaaababa=a >
bbbabbaaababa -> a

# < a,b | bbbabbaaabbaa=a >
bbbabbaaabbaa -> a

# < a,b | bbbabbaaabbba=a >
bbbabbaaabbba -> a
bbbabbaaaa -> abbaaabbba

# < a,b | bbbabbaabaaaa=a >
bbbabbaabaaaa -> a

# < a,b | bbbabbaabaaba=a >
bbbabbaabaaba -> a

# < a,b | bbbabbaababaa=a >
bbbabbaababaa -> a

# < a,b | bbbabbaababba=a >
bbbabbaababba -> a

# < a,b | bbbabbaabbaaa=a >
bbbabbaabbaaa -> a

# < a,b | bbbabbaabbaba=a >
bbbabbaabbaba -> a

# < a,b | bbbabbaabbbaa=a >
bbbabbaabbbaa -> a

# < a,b | bbbabbaabbbba=a >
bbbabbaabbbba -> a
bbbabbaaba -> abbaabbbba

# < a,b | bbbabbabaaaaa=a >
bbbabbabaaaaa -> a

# < a,b | bbbabbabaaaba=a >
bbbabbabaaaba -> a

# < a,b | bbbabbabaabaa=a >
bbbabbabaabaa -> a

# < a,b | bbbabbabaabba=a >
bbbabbabaabba -> a

# < a,b | bbbabbababaaa=a >
bbbabbababaaa -> a

# < a,b | bbbabbabababa=a >
bbbabbabababa -> a

# < a,b | bbbabbababbaa=a >
bbbabbababbaa -> a

# < a,b | bbbabbababbba=a >
bbbabbababbba -> a
bbbabbabaa -> abbababbba

# < a,b | bbbabbabbaaaa=a >
bbbabbabbaaaa -> a

# < a,b | bbbabbabbaaba=a >
bbbabbabbaaba -> a

# < a,b | bbbabbabbabaa=a >
bbbabbabbabaa -> a

# < a,b | bbbabbabbabba=a >
bbbabbabbabba -> a

# < a,b | bbbabbabbbaaa=a >
bbbabbabbbaaa -> a

# < a,b | bbbabbabbbaba=a >
bbbabbabbbaba -> a

# < a,b | bbbabbabbbbaa=a >
bbbabbabbbbaa -> a

# < a,b | bbbabbabbbbba=a >
bbbabbabbbbba -> a
bbbabbabba -> abbabbbbba

# < a,b | bbbabbbaaaaaa=a >
bbbabbbaaaaaa -> a

# < a,b | bbbabbbaaaaba=a >
bbbabbbaaaaba -> a

# < a,b | bbbabbbaaabaa=a >
bbbabbbaaabaa -> a

# < a,b | bbbabbbaaabba=a >
bbbabbbaaabba -> a

# < a,b | bbbabbbaabaaa=a >
bbbabbbaabaaa -> a

# < a,b | bbbabbbaababa=a >
bbbabbbaababa -> a

# < a,b | bbbabbbaabbaa=a >
bbbabbbaabbaa -> a

# < a,b | bbbabbbaabbba=a >
bbbabbbaabbba -> a
bbbabbbaaa -> abbbaabbba

# < a,b | bbbabbbabaaaa=a >
bbbabbbabaaaa -> a

# < a,b | bbbabbbabaaba=a >
bbbabbbabaaba -> a

# < a,b | bbbabbbababaa=a >
bbbabbbababaa -> a

# < a,b | bbbabbbababba=a >
bbbabbbababba -> a

# < a,b | bbbabbbabbaaa=a >
bbbabbbabbaaa -> a

# < a,b | bbbabbbabbaba=a >
bbbabbbabbaba -> a

# < a,b | bbbabbbabbbaa=a >
bbbabbbabbbaa -> a

# < a,b | bbbabbbabbbba=a >
bbbabbbabbbba -> a
bbbabbbaba -> abbbabbbba

# < a,b | bbbabbbbaaaaa=a >
bbbabbbbaaaaa -> a

# < a,b | bbbabbbbaaaba=a >
bbbabbbbaaaba -> a

# < a,b | bbbabbbbaabaa=a >
bbbabbbbaabaa -> a

# < a,b | bbbabbbbaabba=a >
bbbabbbbaabba -> a

# < a,b | bbbabbbbabaaa=a >
bbbabbbbabaaa -> a

# < a,b | bbbabbbbababa=a >
bbbabbbbababa -> a

# < a,b | bbbabbbbabbaa=a >
bbbabbbbabbaa -> a

# < a,b | bbbabbbbabbba=a >
bbbabbbbabbba -> a
bbbabbbbaa -> abbbbabbba

# < a,b | bbbabbbbbaaaa=a >
bbbabbbbbaaaa -> a

# < a,b | bbbabbbbbaaba=a >
bbbabbbbbaaba -> a

# < a,b | bbbabbbbbabaa=a >
bbbabbbbbabaa -> a

# < a,b | bbbabbbbbabba=a >
bbbabbbbbabba -> a

# < a,b | bbbabbbbbbaaa=a >
bbbabbbbbbaaa -> a

# < a,b | bbbabbbbbbaba=a >
bbbabbbbbbaba -> a

# < a,b | bbbabbbbbbbaa=a >
bbbabbbbbbbaa -> a

# < a,b | bbbabbbbbbbba=a >
bbbabbbbbbbba -> a
bbbabbbbba -> abbbbbbbba
bbbabba -> abbbbba

# < a,b | bbbbaaaaaaaaa=a >
bbbbaaaaaaaaa -> a

# < a,b | bbbbaaaaaaaba=a >
bbbbaaaaaaaba -> a

# < a,b | bbbbaaaaaabaa=a >
bbbbaaaaaabaa -> a

# < a,b | bbbbaaaaaabba=a >
bbbbaaaaaabba -> a

# < a,b | bbbbaaaaabaaa=a >
bbbbaaaaabaaa -> a

# < a,b | bbbbaaaaababa=a >
bbbbaaaaababa -> a

# < a,b | bbbbaaaaabbaa=a >
bbbbaaaaabbaa -> a

# < a,b | bbbbaaaaabbba=a >
bbbbaaaaabbba -> a

# < a,b | bbbbaaaabaaaa=a >
bbbbaaaabaaaa -> a

# < a,b | bbbbaaaabaaba=a >
bbbbaaaabaaba -> a

# < a,b | bbbbaaaababaa=a >
bbbbaaaababaa -> a

# < a,b | bbbbaaaababba=a >
bbbbaaaababba -> a

# < a,b | bbbbaaaabbaaa=a >
bbbbaaaabbaaa -> a

# < a,b | bbbbaaaabbaba=a >
bbbbaaaabbaba -> a

# < a,b | bbbbaaaabbbaa=a >
bbbbaaaabbbaa -> a

# < a,b | bbbbaaaabbbba=a >
bbbbaaaabbbba -> a
bbbbaaaaa -> aaaabbbba

# < a,b | bbbbaaabaaaaa=a >
bbbbaaabaaaaa -> a

# < a,b | bbbbaaabaaaba=a >
bbbbaaabaaaba -> a

# < a,b | bbbbaaabaabaa=a >
bbbbaaabaabaa -> a

# < a,b | bbbbaaabaabba=a >
bbbbaaabaabba -> a

# < a,b | bbbbaaababaaa=a >
bbbbaaababaaa -> a

# < a,b | bbbbaaabababa=a >
bbbbaaabababa -> a

# < a,b | bbbbaaababbaa=a >
bbbbaaababbaa -> a

# < a,b | bbbbaaababbba=a >
bbbbaaababbba -> a

# < a,b | bbbbaaabbaaaa=a >
bbbbaaabbaaaa -> a

# < a,b | bbbbaaabbaaba=a >
bbbbaaabbaaba -> a

# < a,b | bbbbaaabbabaa=a >
bbbbaaabbabaa -> a

# < a,b | bbbbaaabbabba=a >
bbbbaaabbabba -> a

# < a,b | bbbbaaabbbaaa=a >
bbbbaaabbbaaa -> a

# < a,b | bbbbaaabbbaba=a >
bbbbaaabbbaba -> a

# < a,b | bbbbaaabbbbaa=a >
bbbbaaabbbbaa -> a
bbbbaaaa -> aabbbbaa

# < a,b | bbbbaaabbbbba=a >
bbbbaaabbbbba -> a
bbbbaaaba -> aaabbbbba

# < a,b | bbbbaabaaaaaa=a >
bbbbaabaaaaaa -> a

# < a,b | bbbbaabaaaaba=a >
bbbbaabaaaaba -> a

# < a,b | bbbbaabaaabaa=a >
bbbbaabaaabaa -> a

# < a,b | bbbbaabaaabba=a >
bbbbaabaaabba -> a

# < a,b | bbbbaabaabaaa=a >
bbbbaabaabaaa -> a

# < a,b | bbbbaabaababa=a >
bbbbaabaababa -> a

# < a,b | bbbbaabaabbaa=a >
bbbbaabaabbaa -> a

# < a,b | bbbbaabaabbba=a >
bbbbaabaabbba -> a

# < a,b | bbbbaababaaaa=a >
bbbbaababaaaa -> a

# < a,b | bbbbaababaaba=a >
bbbbaababaaba -> a

# < a,b | bbbbaabababaa=a >
bbbbaabababaa -> a

# < a,b | bbbbaabababba=a >
bbbbaabababba -> a

# < a,b | bbbbaababbaaa=a >
bbbbaababbaaa -> a

# < a,b | bbbbaababbaba=a >
bbbbaababbaba -> a

# < a,b | bbbbaababbbaa=a >
bbbbaababbbaa -> a

# < a,b | bbbbaababbbba=a >
bbbbaababbbba -> a
bbbbaabaa -> aababbbba

# < a,b | bbbbaabbaaaaa=a >
bbbbaabbaaaaa -> a

# < a,b | bbbbaabbaaaba=a >
bbbbaabbaaaba -> a

# < a,b | bbbbaabbaabaa=a >
bbbbaabbaabaa -> a

# < a,b | bbbbaabbaabba=a >
bbbbaabbaabba -> a

# < a,b | bbbbaabbabaaa=a >
bbbbaabbabaaa -> a

# < a,b | bbbbaabbababa=a >
bbbbaabbababa -> a

# < a,b | bbbbaabbabbaa=a >
bbbbaabbabbaa -> a

# < a,b | bbbbaabbabbba=a >
bbbbaabbabbba -> a

# < a,b | bbbbaabbbaaaa=a >
bbbbaabbbaaaa -> a

# < a,b | bbbbaabbbaaba=a >
bbbbaabbbaaba -> a

# < a,b | bbbbaabbbabaa=a >
bbbbaabbbabaa -> a

# < a,b | bbbbaabbbabba=a >
bbbbaabbbabba -> a

# < a,b | bbbbaabbbbaaa=a >
bbbbaabbbbaaa -> a

# < a,b | bbbbaabbbbaba=a >
bbbbaabbbbaba -> a

# < a,b | bbbbaabbbbbaa=a >
bbbbaabbbbbaa -> a
bbbbaaba -> abbbbbaa

# < a,b | bbbbaabbbbbba=a >
bbbbaabbbbbba -> a
bbbbaabba -> aabbbbbba

# < a,b | bbbbabaaaaaaa=a >
bbbbabaaaaaaa -> a

# < a,b | bbbbabaaaaaba=a >
bbbbabaaaaaba -> a

# < a,b | bbbbabaaaabaa=a >
bbbbabaaaabaa -> a

# < a,b | bbbbabaaaabba=a >
bbbbabaaaabba -> a

# < a,b | bbbbabaaabaaa=a >
bbbbabaaabaaa -> a

# < a,b | bbbbabaaababa=a >
bbbbabaaababa -> a

# < a,b | bbbbabaaabbaa=a >
bbbbabaaabbaa -> a

# < a,b | bbbbabaaabbba=a >
bbbbabaaabbba -> a

# < a,b | bbbbabaabaaaa=a >
bbbbabaabaaaa -> a

# < a,b | bbbbabaabaaba=a >
bbbbabaabaaba -> a

# < a,b | bbbbabaababaa=a >
bbbbabaababaa -> a

# < a,b | bbbbabaababba=a >
bbbbabaababba -> a

# < a,b | bbbbabaabbaaa=a >
bbbbabaabbaaa -> a

# < a,b | bbbbabaabbaba=a >
bbbbabaabbaba -> a

# < a,b | bbbbabaabbbaa=a >
bbbbabaabbbaa -> a

# < a,b | bbbbabaabbbba=a >
bbbbabaabbbba -> a
bbbbabaaa -> abaabbbba

# < a,b | bbbbababaaaaa=a >
bbbbababaaaaa -> a

# < a,b | bbbbababaaaba=a >
bbbbababaaaba -> a

# < a,b | bbbbababaabaa=a >
bbbbababaabaa -> a

# < a,b | bbbbababaabba=a >
bbbbababaabba -> a

# < a,b | bbbbabababaaa=a >
bbbbabababaaa -> a

# < a,b | bbbbababababa=a >
bbbbababababa -> a

# < a,b | bbbbabababbaa=a >
bbbbabababbaa -> a

# < a,b | bbbbabababbba=a >
bbbbabababbba -> a

# < a,b | bbbbababbaaaa=a >
bbbbababbaaaa -> a

# < a,b | bbbbababbaaba=a >
bbbbababbaaba -> a

# < a,b | bbbbababbabaa=a >
bbbbababbabaa -> a

# < a,b | bbbbababbabba=a >
bbbbababbabba -> a

# < a,b | bbbbababbbaaa=a >
bbbbababbbaaa -> a

# < a,b | bbbbababbbaba=a >
bbbbababbbaba -> a

# < a,b | bbbbababbbbaa=a >
bbbbababbbbaa -> a

# < a,b | bbbbababbbbba=a >
bbbbababbbbba -> a
bbbbababa -> ababbbbba

# < a,b | bbbbabbaaaaaa=a >
bbbbabbaaaaaa -> a

# < a,b | bbbbabbaaaaba=a >
bbbbabbaaaaba -> a

# < a,b | bbbbabbaaabaa=a >
bbbbabbaaabaa -> a

# < a,b | bbbbabbaaabba=a >
bbbbabbaaabba -> a

# < a,b | bbbbabbaabaaa=a >
bbbbabbaabaaa -> a

# < a,b | bbbbabbaababa=a >
bbbbabbaababa -> a

# < a,b | bbbbabbaabbaa=a >
bbbbabbaabbaa -> a

# < a,b | bbbbabbaabbba=a >
bbbbabbaabbba -> a

# < a,b | bbbbabbabaaaa=a >
bbbbabbabaaaa -> a

# < a,b | bbbbabbabaaba=a >
bbbbabbabaaba -> a

# < a,b | bbbbabbababaa=a >
bbbbabbababaa -> a

# < a,b | bbbbabbababba=a >
bbbbabbababba -> a

# < a,b | bbbbabbabbaaa=a >
bbbbabbabbaaa -> a

# < a,b | bbbbabbabbaba=a >
bbbbabbabbaba -> a

# < a,b | bbbbabbabbbaa=a >
bbbbabbabbbaa -> a

# < a,b | bbbbabbabbbba=a >
bbbbabbabbbba -> a
bbbbabbaa -> abbabbbba

# < a,b | bbbbabbbaaaaa=a >
bbbbabbbaaaaa -> a

# < a,b | bbbbabbbaaaba=a >
bbbbabbbaaaba -> a

# < a,b | bbbbabbbaabaa=a >
bbbbabbbaabaa -> a

# < a,b | bbbbabbbaabba=a >
bbbbabbbaabba -> a

# < a,b | bbbbabbbabaaa=a >
bbbbabbbabaaa -> a

# < a,b | bbbbabbbababa=a >
bbbbabbbababa -> a

# < a,b | bbbbabbbabbaa=a >
bbbbabbbabbaa -> a

# < a,b | bbbbabbbabbba=a >
bbbbabbbabbba -> a

# < a,b | bbbbabbbbaaaa=a >
bbbbabbbbaaaa -> a

# < a,b | bbbbabbbbaaba=a >
bbbbabbbbaaba -> a

# < a,b | bbbbabbbbabaa=a >
bbbbabbbbabaa -> a

# < a,b | bbbbabbbbabba=a >
bbbbabbbbabba -> a

# < a,b | bbbbabbbbbaaa=a >
bbbbabbbbbaaa -> a

# < a,b | bbbbabbbbbaba=a >
bbbbabbbbbaba -> a

# < a,b | bbbbabbbbbbaa=a >
bbbbabbbbbbaa -> a

# < a,b | bbbbabbbbbbba=a >
bbbbabbbbbbba -> a
bbbbabbba -> abbbbbbba

# < a,b | bbbbbaaaaaaaa=a >
bbbbbaaaaaaaa -> a

# < a,b | bbbbbaaaaaaba=a >
bbbbbaaaaaaba -> a

# < a,b | bbbbbaaaaabaa=a >
bbbbbaaaaabaa -> a

# < a,b | bbbbbaaaaabba=a >
bbbbbaaaaabba -> a

# < a,b | bbbbbaaaabaaa=a >
bbbbbaaaabaaa -> a

# < a,b | bbbbbaaaababa=a >
bbbbbaaaababa -> a

# < a,b | bbbbbaaaabbaa=a >
bbbbbaaaabbaa -> a

# < a,b | bbbbbaaaabbba=a >
bbbbbaaaabbba -> a

# < a,b | bbbbbaaabaaaa=a >
bbbbbaaabaaaa -> a

# < a,b | bbbbbaaabaaba=a >
bbbbbaaabaaba -> a

# < a,b | bbbbbaaababaa=a >
bbbbbaaababaa -> a

# < a,b | bbbbbaaababba=a >
bbbbbaaababba -> a

# < a,b | bbbbbaaabbaaa=a >
bbbbbaaabbaaa -> a

# < a,b | bbbbbaaabbaba=a >
bbbbbaaabbaba -> a

# < a,b | bbbbbaaabbbaa=a >
bbbbbaaabbbaa -> a

# < a,b | bbbbbaaabbbba=a >
bbbbbaaabbbba -> a

# < a,b | bbbbbaabaaaaa=a >
bbbbbaabaaaaa -> a

# < a,b | bbbbbaabaaaba=a >
bbbbbaabaaaba -> a

# < a,b | bbbbbaabaabaa=a >
bbbbbaabaabaa -> a

# < a,b | bbbbbaabaabba=a >
bbbbbaabaabba -> a

# < a,b | bbbbbaababaaa=a >
bbbbbaababaaa -> a

# < a,b | bbbbbaabababa=a >
bbbbbaabababa -> a

# < a,b | bbbbbaababbaa=a >
bbbbbaababbaa -> a

# < a,b | bbbbbaababbba=a >
bbbbbaababbba -> a

# < a,b | bbbbbaabbaaaa=a >
bbbbbaabbaaaa -> a

# < a,b | bbbbbaabbaaba=a >
bbbbbaabbaaba -> a

# < a,b | bbbbbaabbabaa=a >
bbbbbaabbabaa -> a

# < a,b | bbbbbaabbabba=a >
bbbbbaabbabba -> a

# < a,b | bbbbbaabbbaaa=a >
bbbbbaabbbaaa -> a

# < a,b | bbbbbaabbbaba=a >
bbbbbaabbbaba -> a

# < a,b | bbbbbaabbbbaa=a >
bbbbbaabbbbaa -> a

# < a,b | bbbbbaabbbbba=a >
bbbbbaabbbbba -> a
bbbbbaaa -> aabbbbba

# < a,b | bbbbbabaaaaaa=a >
bbbbbabaaaaaa -> a

# < a,b | bbbbbabaaaaba=a >
bbbbbabaaaaba -> a

# < a,b | bbbbbabaaabaa=a >
bbbbbabaaabaa -> a

# < a,b | bbbbbabaaabba=a >
bbbbbabaaabba -> a

# < a,b | bbbbbabaabaaa=a >
bbbbbabaabaaa -> a

# < a,b | bbbbbabaababa=a >
bbbbbabaababa -> a

# < a,b | bbbbbabaabbaa=a >
bbbbbabaabbaa -> a

# < a,b | bbbbbabaabbba=a >
bbbbbabaabbba -> a

# < a,b | bbbbbababaaaa=a >
bbbbbababaaaa -> a

# < a,b | bbbbbababaaba=a >
bbbbbababaaba -> a

# < a,b | bbbbbabababaa=a >
bbbbbabababaa -> a

# < a,b | bbbbbabababba=a >
bbbbbabababba -> a

# < a,b | bbbbbababbaaa=a >
bbbbbababbaaa -> a

# < a,b | bbbbbababbaba=a >
bbbbbababbaba -> a

# < a,b | bbbbbababbbaa=a >
bbbbbababbbaa -> a

# < a,b | bbbbbababbbba=a >
bbbbbababbbba -> a

# < a,b | bbbbbabbaaaaa=a >
bbbbbabbaaaaa -> a

# < a,b | bbbbbabbaaaba=a >
bbbbbabbaaaba -> a

# < a,b | bbbbbabbaabaa=a >
bbbbbabbaabaa -> a

# < a,b | bbbbbabbaabba=a >
bbbbbabbaabba -> a

# < a,b | bbbbbabbabaaa=a >
bbbbbabbabaaa -> a

# < a,b | bbbbbabbababa=a >
bbbbbabbababa -> a

# < a,b | bbbbbabbabbaa=a >
bbbbbabbabbaa -> a

# < a,b | bbbbbabbabbba=a >
bbbbbabbabbba -> a

# < a,b | bbbbbabbbaaaa=a >
bbbbbabbbaaaa -> a

# < a,b | bbbbbabbbaaba=a >
bbbbbabbbaaba -> a

# < a,b | bbbbbabbbabaa=a >
bbbbbabbbabaa -> a

# < a,b | bbbbbabbbabba=a >
bbbbbabbbabba -> a

# < a,b | bbbbbabbbbaaa=a >
bbbbbabbbbaaa -> a

# < a,b | bbbbbabbbbaba=a >
bbbbbabbbbaba -> a

# < a,b | bbbbbabbbbbaa=a >
bbbbbabbbbbaa -> a

# < a,b | bbbbbabbbbbba=a >
bbbbbabbbbbba -> a
bbbbbaba -> abbbbbba

# < a,b | bbbbbbaaaaaaa=a >
bbbbbbaaaaaaa -> a

# < a,b | bbbbbbaaaaaba=a >
bbbbbbaaaaaba -> a

# < a,b | bbbbbbaaaabaa=a >
bbbbbbaaaabaa -> a

# < a,b | bbbbbbaaaabba=a >
bbbbbbaaaabba -> a

# < a,b | bbbbbbaaabaaa=a >
bbbbbbaaabaaa -> a

# < a,b | bbbbbbaaababa=a >
bbbbbbaaababa -> a

# < a,b | bbbbbbaaabbaa=a >
bbbbbbaaabbaa -> a

# < a,b | bbbbbbaaabbba=a >
bbbbbbaaabbba -> a

# < a,b | bbbbbbaabaaaa=a >
bbbbbbaabaaaa -> a

# < a,b | bbbbbbaabaaba=a >
bbbbbbaabaaba -> a

# < a,b | bbbbbbaababaa=a >
bbbbbbaababaa -> a

# < a,b | bbbbbbaababba=a >
bbbbbbaababba -> a

# < a,b | bbbbbbaabbaaa=a >
bbbbbbaabbaaa -> a

# < a,b | bbbbbbaabbaba=a >
bbbbbbaabbaba -> a

# < a,b | bbbbbbaabbbaa=a >
bbbbbbaabbbaa -> a

# < a,b | bbbbbbaabbbba=a >
bbbbbbaabbbba -> a

# < a,b | bbbbbbabaaaaa=a >
bbbbbbabaaaaa -> a

# < a,b | bbbbbbabaaaba=a >
bbbbbbabaaaba -> a

# < a,b | bbbbbbabaabaa=a >
bbbbbbabaabaa -> a

# < a,b | bbbbbbabaabba=a >
bbbbbbabaabba -> a

# < a,b | bbbbbbababaaa=a >
bbbbbbababaaa -> a

# < a,b | bbbbbbabababa=a >
bbbbbbabababa -> a

# < a,b | bbbbbbababbaa=a >
bbbbbbababbaa -> a

# < a,b | bbbbbbababbba=a >
bbbbbbababbba -> a

# < a,b | bbbbbbabbaaaa=a >
bbbbbbabbaaaa -> a

# < a,b | bbbbbbabbaaba=a >
bbbbbbabbaaba -> a

# < a,b | bbbbbbabbabaa=a >
bbbbbbabbabaa -> a

# < a,b | bbbbbbabbabba=a >
bbbbbbabbabba -> a

# < a,b | bbbbbbabbbaaa=a >
bbbbbbabbbaaa -> a

# < a,b | bbbbbbabbbaba=a >
bbbbbbabbbaba -> a

# < a,b | bbbbbbabbbbaa=a >
bbbbbbabbbbaa -> a

# < a,b | bbbbbbabbbbba=a >
bbbbbbabbbbba -> a

# < a,b | bbbbbbbaaaaaa=a >
bbbbbbbaaaaaa -> a

# < a,b | bbbbbbbaaaaba=a >
bbbbbbbaaaaba -> a

# < a,b | bbbbbbbaaabaa=a >
bbbbbbbaaabaa -> a

# < a,b | bbbbbbbaaabba=a >
bbbbbbbaaabba -> a

# < a,b | bbbbbbbaabaaa=a >
bbbbbbbaabaaa -> a

# < a,b | bbbbbbbaababa=a >
bbbbbbbaababa -> a

# < a,b | bbbbbbbaabbaa=a >
bbbbbbbaabbaa -> a

# < a,b | bbbbbbbaabbba=a >
bbbbbbbaabbba -> a

# < a,b | bbbbbbbabaaaa=a >
bbbbbbbabaaaa -> a

# < a,b | bbbbbbbabaaba=a >
bbbbbbbabaaba -> a

# < a,b | bbbbbbbababaa=a >
bbbbbbbababaa -> a

# < a,b | bbbbbbbababba=a >
bbbbbbbababba -> a

# < a,b | bbbbbbbabbaaa=a >
bbbbbbbabbaaa -> a

# < a,b | bbbbbbbabbaba=a >
bbbbbbbabbaba -> a

# < a,b | bbbbbbbabbbaa=a >
bbbbbbbabbbaa -> a

# < a,b | bbbbbbbabbbba=a >
bbbbbbbabbbba -> a

# < a,b | bbbbbbbbaaaaa=a >
bbbbbbbbaaaaa -> a

# < a,b | bbbbbbbbaaaba=a >
bbbbbbbbaaaba -> a

# < a,b | bbbbbbbbaabaa=a >
bbbbbbbbaabaa -> a

# < a,b | bbbbbbbbaabba=a >
bbbbbbbbaabba -> a

# < a,b | bbbbbbbbabaaa=a >
bbbbbbbbabaaa -> a

# < a,b | bbbbbbbbababa=a >
bbbbbbbbababa -> a

# < a,b | bbbbbbbbabbaa=a >
bbbbbbbbabbaa -> a

# < a,b | bbbbbbbbabbba=a >
bbbbbbbbabbba -> a

# < a,b | bbbbbbbbbaaaa=a >
bbbbbbbbbaaaa -> a

# < a,b | bbbbbbbbbaaba=a >
bbbbbbbbbaaba -> a

# < a,b | bbbbbbbbbabaa=a >
bbbbbbbbbabaa -> a

# < a,b | bbbbbbbbbabba=a >
bbbbbbbbbabba -> a

# < a,b | bbbbbbbbbbaaa=a >
bbbbbbbbbbaaa -> a

# < a,b | bbbbbbbbbbaba=a >
bbbbbbbbbbaba -> a

# < a,b | bbbbbbbbbbbaa=a >
bbbbbbbbbbbaa -> a

# < a,b | bbbbbbbbbbbba=a >
bbbbbbbbbbbba -> a

# < a,b | baaaaaaaaaaaaa=a >
baaaaaaaaaaaaa -> a

# < a,b | baaaaaaaaaaaba=a >
baaaaaaaaaaaba -> a
baaaaaaaaaaaa -> aaaaaaaaaaaba

# < a,b | baaaaaaaaaabaa=a >
baaaaaaaaaabaa -> a
baaaaaaaaaaa -> aaaaaaaaabaa

# < a,b | baaaaaaaaaabba=a >
baaaaaaaaaabba -> a
baaaaaaaaaaba -> aaaaaaaaaabba
baaaaaaaaaaa -> aaaaaaaaaaba

# < a,b | baaaaaaaaabaaa=a >
baaaaaaaaabaaa -> a
baaaaaaaaaa -> aaaaaaabaaa

# < a,b | baaaaaaaaabbba=a >
baaaaaaaaabbba -> a
baaaaaaaaabba -> aaaaaaaaabbba
baaaaaaaaaba -> aaaaaaaaabba
baaaaaaaaaa -> aaaaaaaaaba

# < a,b | baaaaaaaabaaaa=a >
baaaaaaaabaaaa -> a
baaaaaaaaa -> aaaaabaaaa

# < a,b | baaaaaaaababaa=a >
baaaaaaaababaa -> a
baaaaaaaabaa -> aaaaaaababaa
baaaaaaaaa -> aaaaaaabaa

# < a,b | baaaaaaaabbbba=a >
baaaaaaaabbbba -> a
baaaaaaaabbba -> aaaaaaaabbbba
baaaaaaaabba -> aaaaaaaabbba
baaaaaaaaba -> aaaaaaaabba
baaaaaaaaa -> aaaaaaaaba

# < a,b | baaaaaaabaaaaa=a >
baaaaaaabaaaaa -> a
baaaaaaaa -> aaabaaaaa

# < a,b | baaaaaaabbbbba=a >
baaaaaaabbbbba -> a
baaaaaaabbbba -> aaaaaaabbbbba
baaaaaaabbba -> aaaaaaabbbba
baaaaaaabba -> aaaaaaabbba
baaaaaaaba -> aaaaaaabba
baaaaaaaa -> aaaaaaaba

# < a,b | baaaaaabaaaaaa=a >
baaaaaabaaaaaa -> a
baaaaaaa -> abaaaaaa

# < a,b | baaaaaabaabaaa=a >
baaaaaabaabaaa -> a
baaaaaabaaa -> aaaabaabaaa
baaaaaaa -> aaaabaaa

# < a,b | baaaaaabababaa=a >
baaaaaabababaa -> a
baaaaaababaa -> aaaaabababaa
baaaaaabaa -> aaaaababaa
baaaaaaa -> aaaaabaa

# < a,b | baaaaaabbbbbba=a >
baaaaaabbbbbba -> a
baaaaaabbbbba -> aaaaaabbbbbba
baaaaaabbbba -> aaaaaabbbbba
baaaaaabbba -> aaaaaabbbba
baaaaaabba -> aaaaaabbba
baaaaaaba -> aaaaaabba
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaaaaaaa=a >
baaaaabaaaaaaa -> a

# < a,b | baaaaabaaaaaba=a >
baaaaabaaaaaba -> a
baaaaaa -> aaaaaba

# < a,b | baaaaabbaaaaaa=a >
baaaaabbaaaaaa -> a

# < a,b | baaaaabbbbbbba=a >
baaaaabbbbbbba -> a
baaaaabbbbbba -> aaaaabbbbbbba
baaaaabbbbba -> aaaaabbbbbba
baaaaabbbba -> aaaaabbbbba
baaaaabbba -> aaaaabbbba
baaaaabba -> aaaaabbba
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaaaaaaa=a >
baaaabaaaaaaaa -> a

# < a,b | baaaabaaaaaaba=a >
baaaabaaaaaaba -> a
baaaabaaaaaaa -> aaaabaaaaaaba

# < a,b | baaaabaaaaabaa=a >
baaaabaaaaabaa -> a
baaaabaaaaaa -> aaabaaaaabaa

# < a,b | baaaabaaaaabba=a >
baaaabaaaaabba -> a
baaaabaaaaaba -> aaaabaaaaabba
baaaabaaaaaa -> aaaabaaaaaba

# < a,b | baaaabaaaabaaa=a >
baaaabaaaabaaa -> a
baaaaa -> aabaaa

# < a,b | baaaabaaabaaaa=a >
baaaabaaabaaaa -> a
baaaabaaaa -> abaaabaaaa
baaaaa -> abaaaa

# < a,b | baaaabaabaaaaa=a >
baaaabaabaaaaa -> a

# < a,b | baaaababaaaaaa=a >
baaaababaaaaaa -> a

# < a,b | baaaababababaa=a >
baaaababababaa -> a
baaaabababaa -> aaababababaa
baaaababaa -> aaabababaa
baaaabaa -> aaababaa
baaaaa -> aaabaa

# < a,b | baaaababbaaaaa=a >
baaaababbaaaaa -> a

# < a,b | baaaabbaaaaaaa=a >
baaaabbaaaaaaa -> a

# < a,b | baaaabbaaaaaba=a >
baaaabbaaaaaba -> a
baaaabbaaaaaa -> aaaabbaaaaaba

# < a,b | baaaabbaaaabaa=a >
baaaabbaaaabaa -> a
baaaabbaaaaa -> aaabbaaaabaa

# < a,b | baaaabbaaaabba=a >
baaaabbaaaabba -> a
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaaabbabaaaaa=a >
baaaabbabaaaaa -> a

# < a,b | baaaabbbaaaaaa=a >
baaaabbbaaaaaa -> a

# < a,b | baaaabbbaaaaba=a >
baaaabbbaaaaba -> a
baaaabbbaaaaa -> aaaabbbaaaaba

# < a,b | baaaabbbbaaaaa=a >
baaaabbbbaaaaa -> a

# < a,b | baaaabbbbbbbba=a >
baaaabbbbbbbba -> a
baaaabbbbbbba -> aaaabbbbbbbba
baaaabbbbbba -> aaaabbbbbbba
baaaabbbbba -> aaaabbbbbba
baaaabbbba -> aaaabbbbba
baaaabbba -> aaaabbbba
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaaaaaaa=a >
baaabaaaaaaaaa -> a

# < a,b | baaabaaaaaaaba=a >
baaabaaaaaaaba -> a
baaabaaaaaaaa -> aaabaaaaaaaba

# < a,b | baaabaaaaaabaa=a >
baaabaaaaaabaa -> a
baaabaaaaaaa -> aabaaaaaabaa

# < a,b | baaabaaaaaabba=a >
baaabaaaaaabba -> a
baaabaaaaaaba -> aaabaaaaaabba
baaabaaaaaaa -> aaabaaaaaaba

# < a,b | baaabaaaaabaaa=a >
baaabaaaaabaaa -> a
baaabaaaaaa -> abaaaaabaaa

# < a,b | baaabaaaaabbba=a >
baaabaaaaabbba -> a
baaabaaaaabba -> aaabaaaaabbba
baaabaaaaaba -> aaabaaaaabba
baaabaaaaaa -> aaabaaaaaba

# < a,b | baaabaaaabaaaa=a >
baaabaaaabaaaa -> a

# < a,b | baaabaaaababaa=a >
baaabaaaababaa -> a
baaabaaaabaa -> aabaaaababaa
baaabaaaaa -> aabaaaabaa

# < a,b | baaabaaaabbbba=a >
baaabaaaabbbba -> a
baaabaaaabbba -> aaabaaaabbbba
baaabaaaabba -> aaabaaaabbba
baaabaaaaba -> aaabaaaabba
baaabaaaaa -> aaabaaaaba

# < a,b | baaabaaabaaaaa=a >
baaabaaabaaaaa -> a

# < a,b | baaabaaabaaaba=a >
baaabaaabaaaba -> a
baaaa -> aaaba

# < a,b | baaabaaabbaaaa=a >
baaabaaabbaaaa -> a

# < a,b | baaabaabaaaaaa=a >
baaabaabaaaaaa -> a

# < a,b | baaabaabaaaaba=a >
baaabaabaaaaba -> a
baaabaabaaaaa -> aaabaabaaaaba

# < a,b | baaabaabaabaaa=a >
baaabaabaabaaa -> a
baaabaabaaa -> abaabaabaaa
baaabaaa -> abaabaaa
baaaa -> abaaa

# < a,b | baaabaababaaaa=a >
baaabaababaaaa -> a

# < a,b | baaabaabbaaaaa=a >
baaabaabbaaaaa -> a

# < a,b | baaabaabbbaaaa=a >
baaabaabbbaaaa -> a

# < a,b | baaababaaaaaaa=a >
baaababaaaaaaa -> a

# < a,b | baaababaaaaaba=a >
baaababaaaaaba -> a
baaababaaaaaa -> aaababaaaaaba

# < a,b | baaababaaaabaa=a >
baaababaaaabaa -> a
baaababaaaaa -> aababaaaabaa

# < a,b | baaababaaaabba=a >
baaababaaaabba -> a
baaababaaaaba -> aaababaaaabba
baaababaaaaa -> aaababaaaaba

# < a,b | baaababaaabaaa=a >
baaababaaabaaa -> a
baaababaaaa -> ababaaabaaa

# < a,b | baaababaabaaaa=a >
baaababaabaaaa -> a

# < a,b | baaabababaaaaa=a >
baaabababaaaaa -> a

# < a,b | baaabababbaaaa=a >
baaabababbaaaa -> a

# < a,b | baaababbaaaaaa=a >
baaababbaaaaaa -> a

# < a,b | baaababbaaaaba=a >
baaababbaaaaba -> a
baaababbaaaaa -> aaababbaaaaba

# < a,b | baaababbaaabaa=a >
baaababbaaabaa -> a
baaababbaaaa -> aababbaaabaa

# < a,b | baaababbabaaaa=a >
baaababbabaaaa -> a

# < a,b | baaababbbaaaaa=a >
baaababbbaaaaa -> a

# < a,b | baaababbbbaaaa=a >
baaababbbbaaaa -> a

# < a,b | baaabbaaaaaaaa=a >
baaabbaaaaaaaa -> a

# < a,b | baaabbaaaaaaba=a >
baaabbaaaaaaba -> a
baaabbaaaaaaa -> aaabbaaaaaaba

# < a,b | baaabbaaaaabaa=a >
baaabbaaaaabaa -> a
baaabbaaaaaa -> aabbaaaaabaa

# < a,b | baaabbaaaaabba=a >
baaabbaaaaabba -> a
baaabbaaaaaba -> aaabbaaaaabba
baaabbaaaaaa -> aaabbaaaaaba

# < a,b | baaabbaaaabaaa=a >
baaabbaaaabaaa -> a
baaabbaaaaa -> abbaaaabaaa

# < a,b | baaabbaaaabbba=a >
baaabbaaaabbba -> a
baaabbaaaabba -> aaabbaaaabbba
baaabbaaaaba -> aaabbaaaabba
baaabbaaaaa -> aaabbaaaaba

# < a,b | baaabbaaabaaaa=a >
baaabbaaabaaaa -> a

# < a,b | baaabbaaababaa=a >
baaabbaaababaa -> a
baaabbaaabaa -> aabbaaababaa
baaabbaaaa -> aabbaaabaa

# < a,b | baaabbaabaaaaa=a >
baaabbaabaaaaa -> a

# < a,b | baaabbaabaaaba=a >
baaabbaabaaaba -> a
baaabbaabaaaa -> aaabbaabaaaba

# < a,b | baaabbaabbaaaa=a >
baaabbaabbaaaa -> a

# < a,b | baaabbabaaaaaa=a >
baaabbabaaaaaa -> a

# < a,b | baaabbabaaaaba=a >
baaabbabaaaaba -> a
baaabbabaaaaa -> aaabbabaaaaba

# < a,b | baaabbabaaabaa=a >
baaabbabaaabaa -> a
baaabbabaaaa -> aabbabaaabaa

# < a,b | baaabbababaaaa=a >
baaabbababaaaa -> a

# < a,b | baaabbabbaaaaa=a >
baaabbabbaaaaa -> a

# < a,b | baaabbabbaaaba=a >
baaabbabbaaaba -> a
baaabbabbaaaa -> aaabbabbaaaba

# < a,b | baaabbabbbaaaa=a >
baaabbabbbaaaa -> a

# < a,b | baaabbbaaaaaaa=a >
baaabbbaaaaaaa -> a

# < a,b | baaabbbaaaaaba=a >
baaabbbaaaaaba -> a
baaabbbaaaaaa -> aaabbbaaaaaba

# < a,b | baaabbbaaaabaa=a >
baaabbbaaaabaa -> a
baaabbbaaaaa -> aabbbaaaabaa

# < a,b | baaabbbaaaabba=a >
baaabbbaaaabba -> a
baaabbbaaaaba -> aaabbbaaaabba
baaabbbaaaaa -> aaabbbaaaaba

# < a,b | baaabbbaaabaaa=a >
baaabbbaaabaaa -> a
baaabbbaaaa -> abbbaaabaaa

# < a,b | baaabbbaaabbba=a >
baaabbbaaabbba -> a
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baaabbbaabaaaa=a >
baaabbbaabaaaa -> a

# < a,b | baaabbbabaaaaa=a >
baaabbbabaaaaa -> a

# < a,b | baaabbbabaaaba=a >
baaabbbabaaaba -> a
baaabbbabaaaa -> aaabbbabaaaba

# < a,b | baaabbbabbaaaa=a >
baaabbbabbaaaa -> a

# < a,b | baaabbbbaaaaaa=a >
baaabbbbaaaaaa -> a

# < a,b | baaabbbbaaaaba=a >
baaabbbbaaaaba -> a
baaabbbbaaaaa -> aaabbbbaaaaba

# < a,b | baaabbbbaaabaa=a >
baaabbbbaaabaa -> a
baaabbbbaaaa -> aabbbbaaabaa

# < a,b | baaabbbbaaabba=a >
baaabbbbaaabba -> a
baaabbbbaaaba -> aaabbbbaaabba
baaabbbbaaaa -> aaabbbbaaaba

# < a,b | baaabbbbabaaaa=a >
baaabbbbabaaaa -> a

# < a,b | baaabbbbbaaaaa=a >
baaabbbbbaaaaa -> a

# < a,b | baaabbbbbaaaba=a >
baaabbbbbaaaba -> a
baaabbbbbaaaa -> aaabbbbbaaaba

# < a,b | baaabbbbbbaaaa=a >
baaabbbbbbaaaa -> a

# < a,b | baaabbbbbbbbba=a >
baaabbbbbbbbba -> a
baaabbbbbbbba -> aaabbbbbbbbba
baaabbbbbbba -> aaabbbbbbbba
baaabbbbbba -> aaabbbbbbba
baaabbbbba -> aaabbbbbba
baaabbbba -> aaabbbbba
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaaaaaaa=a >
baabaaaaaaaaaa -> a

# < a,b | baabaaaaaaaaba=a >
baabaaaaaaaaba -> a
baabaaaaaaaaa -> aabaaaaaaaaba

# < a,b | baabaaaaaaabaa=a >
baabaaaaaaabaa -> a
baabaaaaaaaa -> abaaaaaaabaa

# < a,b | baabaaaaaaabba=a >
baabaaaaaaabba -> a
baabaaaaaaaba -> aabaaaaaaabba
baabaaaaaaaa -> aabaaaaaaaba

# < a,b | baabaaaaaabaaa=a >
baabaaaaaabaaa -> a

# < a,b | baabaaaaaabbba=a >
baabaaaaaabbba -> a
baabaaaaaabba -> aabaaaaaabbba
baabaaaaaaba -> aabaaaaaabba
baabaaaaaaa -> aabaaaaaaba

# < a,b | baabaaaaabaaaa=a >
baabaaaaabaaaa -> a

# < a,b | baabaaaaabaaba=a >
baabaaaaabaaba -> a
baabaaaaabaaa -> aabaaaaabaaba
baabaaaaaa -> aaaaabaaba

# < a,b | baabaaaaababaa=a >
baabaaaaababaa -> a
baabaaaaabaa -> abaaaaababaa
baabaaaaaa -> abaaaaabaa

# < a,b | baabaaaaabbaaa=a >
baabaaaaabbaaa -> a

# < a,b | baabaaaaabbbba=a >
baabaaaaabbbba -> a
baabaaaaabbba -> aabaaaaabbbba
baabaaaaabba -> aabaaaaabbba
baabaaaaaba -> aabaaaaabba
baabaaaaaa -> aabaaaaaba

# < a,b | baabaaaabaaaaa=a >
baabaaaabaaaaa -> a

# < a,b | baabaaaabaaaba=a >
baabaaaabaaaba -> a
baabaaaabaaaa -> aabaaaabaaaba

# < a,b | baabaaaabaabaa=a >
baabaaaabaabaa -> a
baabaaaabaaa -> abaaaabaabaa
baabaaaaa -> aaabaabaa

# < a,b | baabaaaababaaa=a >
baabaaaababaaa -> a

# < a,b | baabaaaabbaaaa=a >
baabaaaabbaaaa -> a

# < a,b | baabaaaabbaaba=a >
baabaaaabbaaba -> a
baabaaaabbaaa -> aabaaaabbaaba
baabaaaaba -> aaaabbaaba
baabaaaaa -> aaaabbaaa

# < a,b | baabaaaabbbaaa=a >
baabaaaabbbaaa -> a

# < a,b | baabaaaabbbbba=a >
baabaaaabbbbba -> a
baabaaaabbbba -> aabaaaabbbbba
baabaaaabbba -> aabaaaabbbba
baabaaaabba -> aabaaaabbba
baabaaaaba -> aabaaaabba
baabaaaaa -> aabaaaaba

# < a,b | baabaaabaaaaaa=a >
baabaaabaaaaaa -> a

# < a,b | baabaaabaaaaba=a >
baabaaabaaaaba -> a
baabaaabaaaaa -> aabaaabaaaaba

# < a,b | baabaaabaaabaa=a >
baabaaabaaabaa -> a
baabaaabaaaa -> abaaabaaabaa

# < a,b | baabaaabaaabba=a >
baabaaabaaabba -> a
baabaaabaaaba -> aabaaabaaabba
baabaaabaaaa -> aabaaabaaaba

# < a,b | baabaaabaabaaa=a >
baabaaabaabaaa -> a
baabaaaa -> abaabaaa

# < a,b | baabaaababaaaa=a >
baabaaababaaaa -> a

# < a,b | baabaaabababaa=a >
baabaaabababaa -> a
baabaaababaa -> abaaabababaa
baabaaabaa -> abaaababaa
baabaaaa -> abaaabaa

# < a,b | baabaaababbaaa=a >
baabaaababbaaa -> a

# < a,b | baabaaabbaaaaa=a >
baabaaabbaaaaa -> a

# < a,b | baabaaabbaaaba=a >
baabaaabbaaaba -> a
baabaaabbaaaa -> aabaaabbaaaba

# < a,b | baabaaabbabaaa=a >
baabaaabbabaaa -> a

# < a,b | baabaaabbbaaaa=a >
baabaaabbbaaaa -> a

# < a,b | baabaaabbbbaaa=a >
baabaaabbbbaaa -> a

# < a,b | baabaaabbbbbba=a >
baabaaabbbbbba -> a
baabaaabbbbba -> aabaaabbbbbba
baabaaabbbba -> aabaaabbbbba
baabaaabbba -> aabaaabbbba
baabaaabba -> aabaaabbba
baabaaaba -> aabaaabba
baabaaaa -> aabaaaba

# < a,b | baabaabaaaaaaa=a >
baabaabaaaaaaa -> a

# < a,b | baabaabaaaaaba=a >
baabaabaaaaaba -> a
baabaabaaaaaa -> aabaabaaaaaba

# < a,b | baabaabaaaabaa=a >
baabaabaaaabaa -> a
baabaabaaaaa -> abaabaaaabaa

# < a,b | baabaabaaaabba=a >
baabaabaaaabba -> a
baabaabaaaaba -> aabaabaaaabba
baabaabaaaaa -> aabaabaaaaba

# < a,b | baabaabaaabaaa=a >
baabaabaaabaaa -> a

# < a,b | baabaabaaabbba=a >
baabaabaaabbba -> a
baabaabaaabba -> aabaabaaabbba
baabaabaaaba -> aabaabaaabba
baabaabaaaa -> aabaabaaaba

# < a,b | baabaabaabaaaa=a >
baabaabaabaaaa -> a

# < a,b | baabaabaabaaba=a >
baabaabaabaaba -> a
baaa -> aaba

# < a,b | baabaabaabbaaa=a >
baabaabaabbaaa -> a

# < a,b | baabaababaaaaa=a >
baabaababaaaaa -> a

# < a,b | baabaababaaaba=a >
baabaababaaaba -> a
baabaababaaaa -> aabaababaaaba

# < a,b | baabaababaabaa=a >
baabaababaabaa -> a
baabaabaa -> ababaabaa
baaa -> abaa

# < a,b | baabaabababaaa=a >
baabaabababaaa -> a

# < a,b | baabaababbaaaa=a >
baabaababbaaaa -> a

# < a,b | baabaababbbaaa=a >
baabaababbbaaa -> a

# < a,b | baabaabbaaaaaa=a >
baabaabbaaaaaa -> a

# < a,b | baabaabbaaaaba=a >
baabaabbaaaaba -> a
baabaabbaaaaa -> aabaabbaaaaba

# < a,b | baabaabbaaabaa=a >
baabaabbaaabaa -> a
baabaabbaaaa -> abaabbaaabaa

# < a,b | baabaabbaaabba=a >
baabaabbaaabba -> a
baabaabbaaaba -> aabaabbaaabba
baabaabbaaaa -> aabaabbaaaba

# < a,b | baabaabbaabaaa=a >
baabaabbaabaaa -> a

# < a,b | baabaabbabaaaa=a >
baabaabbabaaaa -> a

# < a,b | baabaabbabbaaa=a >
baabaabbabbaaa -> a

# < a,b | baabaabbbaaaaa=a >
baabaabbbaaaaa -> a

# < a,b | baabaabbbaaaba=a >
baabaabbbaaaba -> a
baabaabbbaaaa -> aabaabbbaaaba

# < a,b | baabaabbbabaaa=a >
baabaabbbabaaa -> a

# < a,b | baabaabbbbaaaa=a >
baabaabbbbaaaa -> a

# < a,b | baabaabbbbbaaa=a >
baabaabbbbbaaa -> a

# < a,b | baababaaaaaaaa=a >
baababaaaaaaaa -> a

# < a,b | baababaaaaaaba=a >
baababaaaaaaba -> a
baababaaaaaaa -> aababaaaaaaba

# < a,b | baababaaaaabaa=a >
baababaaaaabaa -> a
baababaaaaaa -> ababaaaaabaa

# < a,b | baababaaaaabba=a >
baababaaaaabba -> a
baababaaaaaba -> aababaaaaabba
baababaaaaaa -> aababaaaaaba

# < a,b | baababaaaabaaa=a >
baababaaaabaaa -> a

# < a,b | baababaaaabbba=a >
baababaaaabbba -> a
baababaaaabba -> aababaaaabbba
baababaaaaba -> aababaaaabba
baababaaaaa -> aababaaaaba

# < a,b | baababaaabaaaa=a >
baababaaabaaaa -> a

# < a,b | baababaaabaaba=a >
baababaaabaaba -> a
baababaaabaaa -> aababaaabaaba
baababaaaa -> abaaabaaba

# < a,b | baababaaababaa=a >
baababaaababaa -> a
baababaaabaa -> ababaaababaa
baababaaaa -> ababaaabaa

# < a,b | baababaaabbaaa=a >
baababaaabbaaa -> a

# < a,b | baababaaabbbba=a >
baababaaabbbba -> a
baababaaabbba -> aababaaabbbba
baababaaabba -> aababaaabbba
baababaaaba -> aababaaabba
baababaaaa -> aababaaaba

# < a,b | baababaabaaaaa=a >
baababaabaaaaa -> a

# < a,b | baababaabaaaba=a >
baababaabaaaba -> a
baababaabaaaa -> aababaabaaaba

# < a,b | baababaabaabaa=a >
baababaabaabaa -> a
baababaabaaa -> ababaabaabaa

# < a,b | baababaababaaa=a >
baababaababaaa -> a

# < a,b | baababaabbaaaa=a >
baababaabbaaaa -> a

# < a,b | baababaabbbaaa=a >
baababaabbbaaa -> a

# < a,b | baabababaaaaaa=a >
baabababaaaaaa -> a

# < a,b | baabababaaaaba=a >
baabababaaaaba -> a
baabababaaaaa -> aabababaaaaba

# < a,b | baabababaaabaa=a >
baabababaaabaa -> a
baabababaaaa -> abababaaabaa

# < a,b | baabababaaabba=a >
baabababaaabba -> a
baabababaaaba -> aabababaaabba
baabababaaaa -> aabababaaaba

# < a,b | baabababaabaaa=a >
baabababaabaaa -> a

# < a,b | baababababaaaa=a >
baababababaaaa -> a

# < a,b | baabababababaa=a >
baabababababaa -> a
baababababaa -> abababababaa
baabababaa -> ababababaa
baababaa -> abababaa
baabaa -> ababaa
baaa -> abaa

# < a,b | baababababbaaa=a >
baababababbaaa -> a

# < a,b | baabababbaaaaa=a >
baabababbaaaaa -> a

# < a,b | baabababbaaaba=a >
baabababbaaaba -> a
baabababbaaaa -> aabababbaaaba

# < a,b | baabababbaabaa=a >
baabababbaabaa -> a
baabababbaaa -> abababbaabaa

# < a,b | baabababbabaaa=a >
baabababbabaaa -> a

# < a,b | baabababbbaaaa=a >
baabababbbaaaa -> a

# < a,b | baabababbbbaaa=a >
baabababbbbaaa -> a

# < a,b | baababbaaaaaaa=a >
baababbaaaaaaa -> a

# < a,b | baababbaaaaaba=a >
baababbaaaaaba -> a
baababbaaaaaa -> aababbaaaaaba

# < a,b | baababbaaaabaa=a >
baababbaaaabaa -> a
baababbaaaaa -> ababbaaaabaa

# < a,b | baababbaaaabba=a >
baababbaaaabba -> a
baababbaaaaba -> aababbaaaabba
baababbaaaaa -> aababbaaaaba

# < a,b | baababbaaabaaa=a >
baababbaaabaaa -> a

# < a,b | baababbaaabbba=a >
baababbaaabbba -> a
baababbaaabba -> aababbaaabbba
baababbaaaba -> aababbaaabba
baababbaaaa -> aababbaaaba

# < a,b | baababbaabaaaa=a >
baababbaabaaaa -> a

# < a,b | baababbaabaaba=a >
baababbaabaaba -> a
baababbaabaaa -> aababbaabaaba
baababbaaa -> abbaabaaba

# < a,b | baababbaababaa=a >
baababbaababaa -> a
baababbaabaa -> ababbaababaa
baababbaaa -> ababbaabaa

# < a,b | baababbaabbaaa=a >
baababbaabbaaa -> a

# < a,b | baababbabaaaaa=a >
baababbabaaaaa -> a

# < a,b | baababbabaaaba=a >
baababbabaaaba -> a
baababbabaaaa -> aababbabaaaba

# < a,b | baababbabaabaa=a >
baababbabaabaa -> a
baababbabaaa -> ababbabaabaa

# < a,b | baababbababaaa=a >
baababbababaaa -> a

# < a,b | baababbabbaaaa=a >
baababbabbaaaa -> a

# < a,b | baababbabbbaaa=a >
baababbabbbaaa -> a

# < a,b | baababbbaaaaaa=a >
baababbbaaaaaa -> a

# < a,b | baababbbaaaaba=a >
baababbbaaaaba -> a
baababbbaaaaa -> aababbbaaaaba

# < a,b | baababbbaaabaa=a >
baababbbaaabaa -> a
baababbbaaaa -> ababbbaaabaa

# < a,b | baababbbaaabba=a >
baababbbaaabba -> a
baababbbaaaba -> aababbbaaabba
baababbbaaaa -> aababbbaaaba

# < a,b | baababbbaabaaa=a >
baababbbaabaaa -> a

# < a,b | baababbbabaaaa=a >
baababbbabaaaa -> a

# < a,b | baababbbabbaaa=a >
baababbbabbaaa -> a

# < a,b | baababbbbaaaaa=a >
baababbbbaaaaa -> a

# < a,b | baababbbbaaaba=a >
baababbbbaaaba -> a
baababbbbaaaa -> aababbbbaaaba

# < a,b | baababbbbaabaa=a >
baababbbbaabaa -> a
baababbbbaaa -> ababbbbaabaa

# < a,b | baababbbbabaaa=a >
baababbbbabaaa -> a

# < a,b | baababbbbbaaaa=a >
baababbbbbaaaa -> a

# < a,b | baababbbbbbaaa=a >
baababbbbbbaaa -> a

# < a,b | baabbaaaaaaaaa=a >
baabbaaaaaaaaa -> a

# < a,b | baabbaaaaaaaba=a >
baabbaaaaaaaba -> a
baabbaaaaaaaa -> aabbaaaaaaaba

# < a,b | baabbaaaaaabaa=a >
baabbaaaaaabaa -> a
baabbaaaaaaa -> abbaaaaaabaa

# < a,b | baabbaaaaaabba=a >
baabbaaaaaabba -> a
baabbaaaaaaba -> aabbaaaaaabba
baabbaaaaaaa -> aabbaaaaaaba

# < a,b | baabbaaaaabaaa=a >
baabbaaaaabaaa -> a

# < a,b | baabbaaaaabbba=a >
baabbaaaaabbba -> a
baabbaaaaabba -> aabbaaaaabbba
baabbaaaaaba -> aabbaaaaabba
baabbaaaaaa -> aabbaaaaaba

# < a,b | baabbaaaabaaaa=a >
baabbaaaabaaaa -> a

# < a,b | baabbaaaabaaba=a >
baabbaaaabaaba -> a
baabbaaaabaaa -> aabbaaaabaaba

# < a,b | baabbaaaababaa=a >
baabbaaaababaa -> a
baabbaaaabaa -> abbaaaababaa
baabbaaaaa -> abbaaaabaa

# < a,b | baabbaaaabbaaa=a >
baabbaaaabbaaa -> a

# < a,b | baabbaaaabbbba=a >
baabbaaaabbbba -> a
baabbaaaabbba -> aabbaaaabbbba
baabbaaaabba -> aabbaaaabbba
baabbaaaaba -> aabbaaaabba
baabbaaaaa -> aabbaaaaba

# < a,b | baabbaaabaaaaa=a >
baabbaaabaaaaa -> a

# < a,b | baabbaaabaaaba=a >
baabbaaabaaaba -> a
baabbaaabaaaa -> aabbaaabaaaba

# < a,b | baabbaaabaabaa=a >
baabbaaabaabaa -> a
baabbaaabaaa -> abbaaabaabaa

# < a,b | baabbaaabaabba=a >
baabbaaabaabba -> a
baabbaaabaaba -> aabbaaabaabba
baabbaaaa -> aaabaabba
baabbaaabaaa -> aabbaaabaaba

# < a,b | baabbaaababaaa=a >
baabbaaababaaa -> a

# < a,b | baabbaaabbaaaa=a >
baabbaaabbaaaa -> a

# < a,b | baabbaaabbaaba=a >
baabbaaabbaaba -> a
baabbaaabbaaa -> aabbaaabbaaba

# < a,b | baabbaaabbbaaa=a >
baabbaaabbbaaa -> a

# < a,b | baabbaaabbbbba=a >
baabbaaabbbbba -> a
baabbaaabbbba -> aabbaaabbbbba
baabbaaabbba -> aabbaaabbbba
baabbaaabba -> aabbaaabbba
baabbaaaba -> aabbaaabba
baabbaaaa -> aabbaaaba

# < a,b | baabbaabaaaaaa=a >
baabbaabaaaaaa -> a

# < a,b | baabbaabaaaaba=a >
baabbaabaaaaba -> a
baabbaabaaaaa -> aabbaabaaaaba

# < a,b | baabbaabaaabaa=a >
baabbaabaaabaa -> a
baabbaabaaaa -> abbaabaaabaa

# < a,b | baabbaabaaabba=a >
baabbaabaaabba -> a
baabbaabaaaba -> aabbaabaaabba
baabbaabaaaa -> aabbaabaaaba

# < a,b | baabbaabaabaaa=a >
baabbaabaabaaa -> a

# < a,b | baabbaabaabbaa=a >
baabbaabaabbaa -> a
baabbaabaaba -> abbaabaabbaa
baabbaaa -> abaabbaa
baabbaabaaa -> abbaaabaaba

# < a,b | baabbaababaaaa=a >
baabbaababaaaa -> a

# < a,b | baabbaababaaba=a >
baabbaababaaba -> a
baabbaababaaa -> aabbaababaaba

# < a,b | baabbaabababaa=a >
baabbaabababaa -> a
baabbaababaa -> abbaabababaa
baabbaabaa -> abbaababaa
baabbaaa -> abbaabaa

# < a,b | baabbaababbaaa=a >
baabbaababbaaa -> a

# < a,b | baabbaabbaaaaa=a >
baabbaabbaaaaa -> a

# < a,b | baabbaabbaaaba=a >
baabbaabbaaaba -> a
baabbaabbaaaa -> aabbaabbaaaba

# < a,b | baabbaabbaabaa=a >
baabbaabbaabaa -> a
baabbaabbaaa -> abbaabbaabaa

# < a,b | baabbaabbaabba=a >
baabbaabbaabba -> a
baaba -> aabba
baaa -> aaba

# < a,b | baabbaabbabaaa=a >
baabbaabbabaaa -> a

# < a,b | baabbaabbbaaaa=a >
baabbaabbbaaaa -> a

# < a,b | baabbaabbbaaba=a >
baabbaabbbaaba -> a
baabbaabbbaaa -> aabbaabbbaaba

# < a,b | baabbaabbbbaaa=a >
baabbaabbbbaaa -> a

# < a,b | baabbabaaaaaaa=a >
baabbabaaaaaaa -> a

# < a,b | baabbabaaaaaba=a >
baabbabaaaaaba -> a
baabbabaaaaaa -> aabbabaaaaaba

# < a,b | baabbabaaaabaa=a >
baabbabaaaabaa -> a
baabbabaaaaa -> abbabaaaabaa

# < a,b | baabbabaaaabba=a >
baabbabaaaabba -> a
baabbabaaaaba -> aabbabaaaabba
baabbabaaaaa -> aabbabaaaaba

# < a,b | baabbabaaabaaa=a >
baabbabaaabaaa -> a

# < a,b | baabbabaaabbba=a >
baabbabaaabbba -> a
baabbabaaabba -> aabbabaaabbba
baabbabaaaba -> aabbabaaabba
baabbabaaaa -> aabbabaaaba

# < a,b | baabbabaabaaaa=a >
baabbabaabaaaa -> a

# < a,b | baabbabaabaaba=a >
baabbabaabaaba -> a
baabbabaabaaa -> aabbabaabaaba

# < a,b | baabbabaababaa=a >
baabbabaababaa -> a
baabbabaabaa -> abbabaababaa
baabbabaaa -> abbabaabaa

# < a,b | baabbabaabbaaa=a >
baabbabaabbaaa -> a

# < a,b | baabbababaaaaa=a >
baabbababaaaaa -> a

# < a,b | baabbababaaaba=a >
baabbababaaaba -> a
baabbababaaaa -> aabbababaaaba

# < a,b | baabbababaabaa=a >
baabbababaabaa -> a
baabbababaaa -> abbababaabaa

# < a,b | baabbabababaaa=a >
baabbabababaaa -> a

# < a,b | baabbababbaaaa=a >
baabbababbaaaa -> a

# < a,b | baabbababbaaba=a >
baabbababbaaba -> a
baabbababbaaa -> aabbababbaaba

# < a,b | baabbababbbaaa=a >
baabbababbbaaa -> a

# < a,b | baabbabbaaaaaa=a >
baabbabbaaaaaa -> a

# < a,b | baabbabbaaaaba=a >
baabbabbaaaaba -> a
baabbabbaaaaa -> aabbabbaaaaba

# < a,b | baabbabbaaabaa=a >
baabbabbaaabaa -> a
baabbabbaaaa -> abbabbaaabaa

# < a,b | baabbabbaaabba=a >
baabbabbaaabba -> a
baabbabbaaaba -> aabbabbaaabba
baabbabbaaaa -> aabbabbaaaba

# < a,b | baabbabbaabaaa=a >
baabbabbaabaaa -> a

# < a,b | baabbabbabaaaa=a >
baabbabbabaaaa -> a

# < a,b | baabbabbabaaba=a >
baabbabbabaaba -> a
baabbabbabaaa -> aabbabbabaaba

# < a,b | baabbabbabbaaa=a >
baabbabbabbaaa -> a

# < a,b | baabbabbbaaaaa=a >
baabbabbbaaaaa -> a

# < a,b | baabbabbbaaaba=a >
baabbabbbaaaba -> a
baabbabbbaaaa -> aabbabbbaaaba

# < a,b | baabbabbbaabaa=a >
baabbabbbaabaa -> a
baabbabbbaaa -> abbabbbaabaa

# < a,b | baabbabbbabaaa=a >
baabbabbbabaaa -> a

# < a,b | baabbabbbbaaaa=a >
baabbabbbbaaaa -> a

# < a,b | baabbabbbbaaba=a >
baabbabbbbaaba -> a
baabbabbbbaaa -> aabbabbbbaaba

# < a,b | baabbabbbbbaaa=a >
baabbabbbbbaaa -> a

# < a,b | baabbbaaaaaaaa=a >
baabbbaaaaaaaa -> a

# < a,b | baabbbaaaaaaba=a >
baabbbaaaaaaba -> a
baabbbaaaaaaa -> aabbbaaaaaaba

# < a,b | baabbbaaaaabaa=a >
baabbbaaaaabaa -> a
baabbbaaaaaa -> abbbaaaaabaa

# < a,b | baabbbaaaaabba=a >
baabbbaaaaabba -> a
baabbbaaaaaba -> aabbbaaaaabba
baabbbaaaaaa -> aabbbaaaaaba

# < a,b | baabbbaaaabaaa=a >
baabbbaaaabaaa -> a

# < a,b | baabbbaaaabbba=a >
baabbbaaaabbba -> a
baabbbaaaabba -> aabbbaaaabbba
baabbbaaaaba -> aabbbaaaabba
baabbbaaaaa -> aabbbaaaaba

# < a,b | baabbbaaabaaaa=a >
baabbbaaabaaaa -> a

# < a,b | baabbbaaabaaba=a >
baabbbaaabaaba -> a
baabbbaaabaaa -> aabbbaaabaaba

# < a,b | baabbbaaababaa=a >
baabbbaaababaa -> a
baabbbaaabaa -> abbbaaababaa
baabbbaaaa -> abbbaaabaa

# < a,b | baabbbaaabbaaa=a >
baabbbaaabbaaa -> a

# < a,b | baabbbaaabbbba=a >
baabbbaaabbbba -> a
baabbbaaabbba -> aabbbaaabbbba
baabbbaaabba -> aabbbaaabbba
baabbbaaaba -> aabbbaaabba
baabbbaaaa -> aabbbaaaba

# < a,b | baabbbaabaaaaa=a >
baabbbaabaaaaa -> a

# < a,b | baabbbaabaaaba=a >
baabbbaabaaaba -> a
baabbbaabaaaa -> aabbbaabaaaba

# < a,b | baabbbaabaabaa=a >
baabbbaabaabaa -> a
baabbbaabaaa -> abbbaabaabaa

# < a,b | baabbbaabaabba=a >
baabbbaabaabba -> a
baabbbaabaaba -> aabbbaabaabba
baabbbaabaaa -> aabbbaabaaba

# < a,b | baabbbaababaaa=a >
baabbbaababaaa -> a

# < a,b | baabbbaabbaaaa=a >
baabbbaabbaaaa -> a

# < a,b | baabbbaabbaaba=a >
baabbbaabbaaba -> a
baabbbaabbaaa -> aabbbaabbaaba

# < a,b | baabbbaabbbaaa=a >
baabbbaabbbaaa -> a

# < a,b | baabbbabaaaaaa=a >
baabbbabaaaaaa -> a

# < a,b | baabbbabaaaaba=a >
baabbbabaaaaba -> a
baabbbabaaaaa -> aabbbabaaaaba

# < a,b | baabbbabaaabaa=a >
baabbbabaaabaa -> a
baabbbabaaaa -> abbbabaaabaa

# < a,b | baabbbabaaabba=a >
baabbbabaaabba -> a
baabbbabaaaba -> aabbbabaaabba
baabbbabaaaa -> aabbbabaaaba

# < a,b | baabbbabaabaaa=a >
baabbbabaabaaa -> a

# < a,b | baabbbababaaaa=a >
baabbbababaaaa -> a

# < a,b | baabbbababaaba=a >
baabbbababaaba -> a
baabbbababaaa -> aabbbababaaba

# < a,b | baabbbababbaaa=a >
baabbbababbaaa -> a

# < a,b | baabbbabbaaaaa=a >
baabbbabbaaaaa -> a

# < a,b | baabbbabbaaaba=a >
baabbbabbaaaba -> a
baabbbabbaaaa -> aabbbabbaaaba

# < a,b | baabbbabbaabaa=a >
baabbbabbaabaa -> a
baabbbabbaaa -> abbbabbaabaa

# < a,b | baabbbabbaabba=a >
baabbbabbaabba -> a
baabbbabbaaba -> aabbbabbaabba
baabbbabbaaa -> aabbbabbaaba

# < a,b | baabbbabbabaaa=a >
baabbbabbabaaa -> a

# < a,b | baabbbabbbaaaa=a >
baabbbabbbaaaa -> a

# < a,b | baabbbabbbaaba=a >
baabbbabbbaaba -> a
baabbbabbbaaa -> aabbbabbbaaba

# < a,b | baabbbabbbbaaa=a >
baabbbabbbbaaa -> a

# < a,b | baabbbbaaaaaaa=a >
baabbbbaaaaaaa -> a

# < a,b | baabbbbaaaaaba=a >
baabbbbaaaaaba -> a
baabbbbaaaaaa -> aabbbbaaaaaba

# < a,b | baabbbbaaaabaa=a >
baabbbbaaaabaa -> a
baabbbbaaaaa -> abbbbaaaabaa

# < a,b | baabbbbaaaabba=a >
baabbbbaaaabba -> a
baabbbbaaaaba -> aabbbbaaaabba
baabbbbaaaaa -> aabbbbaaaaba

# < a,b | baabbbbaaabaaa=a >
baabbbbaaabaaa -> a

# < a,b | baabbbbaaabbba=a >
baabbbbaaabbba -> a
baabbbbaaabba -> aabbbbaaabbba
baabbbbaaaba -> aabbbbaaabba
baabbbbaaaa -> aabbbbaaaba

# < a,b | baabbbbaabaaaa=a >
baabbbbaabaaaa -> a

# < a,b | baabbbbaabaaba=a >
baabbbbaabaaba -> a
baabbbbaabaaa -> aabbbbaabaaba

# < a,b | baabbbbaababaa=a >
baabbbbaababaa -> a
baabbbbaabaa -> abbbbaababaa
baabbbbaaa -> abbbbaabaa

# < a,b | baabbbbaabbaaa=a >
baabbbbaabbaaa -> a

# < a,b | baabbbbaabbbba=a >
baabbbbaabbbba -> a
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | baabbbbabaaaaa=a >
baabbbbabaaaaa -> a

# < a,b | baabbbbabaaaba=a >
baabbbbabaaaba -> a
baabbbbabaaaa -> aabbbbabaaaba

# < a,b | baabbbbabaabaa=a >
baabbbbabaabaa -> a
baabbbbabaaa -> abbbbabaabaa

# < a,b | baabbbbabaabba=a >
baabbbbabaabba -> a
baabbbbabaaba -> aabbbbabaabba
baabbbbabaaa -> aabbbbabaaba

# < a,b | baabbbbababaaa=a >
baabbbbababaaa -> a

# < a,b | baabbbbabbaaaa=a >
baabbbbabbaaaa -> a

# < a,b | baabbbbabbaaba=a >
baabbbbabbaaba -> a
baabbbbabbaaa -> aabbbbabbaaba

# < a,b | baabbbbabbbaaa=a >
baabbbbabbbaaa -> a

# < a,b | baabbbbbaaaaaa=a >
baabbbbbaaaaaa -> a

# < a,b | baabbbbbaaaaba=a >
baabbbbbaaaaba -> a
baabbbbbaaaaa -> aabbbbbaaaaba

# < a,b | baabbbbbaaabaa=a >
baabbbbbaaabaa -> a
baabbbbbaaaa -> abbbbbaaabaa

# < a,b | baabbbbbaaabba=a >
baabbbbbaaabba -> a
baabbbbbaaaba -> aabbbbbaaabba
baabbbbbaaaa -> aabbbbbaaaba

# < a,b | baabbbbbaabaaa=a >
baabbbbbaabaaa -> a

# < a,b | baabbbbbaabbba=a >
baabbbbbaabbba -> a
baabbbbbaabba -> aabbbbbaabbba
baabbbbbaaba -> aabbbbbaabba
baabbbbbaaa -> aabbbbbaaba

# < a,b | baabbbbbabaaaa=a >
baabbbbbabaaaa -> a

# < a,b | baabbbbbabaaba=a >
baabbbbbabaaba -> a
baabbbbbabaaa -> aabbbbbabaaba

# < a,b | baabbbbbabbaaa=a >
baabbbbbabbaaa -> a

# < a,b | baabbbbbbaaaaa=a >
baabbbbbbaaaaa -> a

# < a,b | baabbbbbbaaaba=a >
baabbbbbbaaaba -> a
baabbbbbbaaaa -> aabbbbbbaaaba

# < a,b | baabbbbbbaabaa=a >
baabbbbbbaabaa -> a
baabbbbbbaaa -> abbbbbbaabaa

# < a,b | baabbbbbbaabba=a >
baabbbbbbaabba -> a
baabbbbbbaaba -> aabbbbbbaabba
baabbbbbbaaa -> aabbbbbbaaba

# < a,b | baabbbbbbabaaa=a >
baabbbbbbabaaa -> a

# < a,b | baabbbbbbbaaaa=a >
baabbbbbbbaaaa -> a

# < a,b | baabbbbbbbaaba=a >
baabbbbbbbaaba -> a
baabbbbbbbaaa -> aabbbbbbbaaba

# < a,b | baabbbbbbbbaaa=a >
baabbbbbbbbaaa -> a

# < a,b | baabbbbbbbbbba=a >
baabbbbbbbbbba -> a
baabbbbbbbbba -> aabbbbbbbbbba
baabbbbbbbba -> aabbbbbbbbba
baabbbbbbba -> aabbbbbbbba
baabbbbbba -> aabbbbbbba
baabbbbba -> aabbbbbba
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaaaaaaa=a >
babaaaaaaaaaaa -> a

# < a,b | babaaaaaaaaaba=a >
babaaaaaaaaaba -> a
babaaaaaaaaaa -> abaaaaaaaaaba

# < a,b | babaaaaaaaabaa=a >
babaaaaaaaabaa -> a

# < a,b | babaaaaaaaabba=a >
babaaaaaaaabba -> a
babaaaaaaaaba -> abaaaaaaaabba
babaaaaaaaaa -> abaaaaaaaaba

# < a,b | babaaaaaaabaaa=a >
babaaaaaaabaaa -> a

# < a,b | babaaaaaaababa=a >
babaaaaaaababa -> a
babaaaaaaabaa -> abaaaaaaababa
babaaaaaaaa -> aaaaaaababa

# < a,b | babaaaaaaabbaa=a >
babaaaaaaabbaa -> a

# < a,b | babaaaaaaabbba=a >
babaaaaaaabbba -> a
babaaaaaaabba -> abaaaaaaabbba
babaaaaaaaba -> abaaaaaaabba
babaaaaaaaa -> abaaaaaaaba

# < a,b | babaaaaaabaaaa=a >
babaaaaaabaaaa -> a

# < a,b | babaaaaaabaaba=a >
babaaaaaabaaba -> a
babaaaaaabaaa -> abaaaaaabaaba

# < a,b | babaaaaaababaa=a >
babaaaaaababaa -> a
babaaaaaaa -> aaaaababaa

# < a,b | babaaaaaabbaaa=a >
babaaaaaabbaaa -> a

# < a,b | babaaaaaabbaba=a >
babaaaaaabbaba -> a
babaaaaaabbaa -> abaaaaaabbaba
babaaaaaaba -> aaaaaabbaba
babaaaaaaa -> aaaaaabbaa

# < a,b | babaaaaaabbbaa=a >
babaaaaaabbbaa -> a

# < a,b | babaaaaaabbbba=a >
babaaaaaabbbba -> a
babaaaaaabbba -> abaaaaaabbbba
babaaaaaabba -> abaaaaaabbba
babaaaaaaba -> abaaaaaabba
babaaaaaaa -> abaaaaaaba

# < a,b | babaaaaabaaaaa=a >
babaaaaabaaaaa -> a

# < a,b | babaaaaabaaaba=a >
babaaaaabaaaba -> a
babaaaaabaaaa -> abaaaaabaaaba

# < a,b | babaaaaabaabaa=a >
babaaaaabaabaa -> a

# < a,b | babaaaaabaabba=a >
babaaaaabaabba -> a
babaaaaabaaba -> abaaaaabaabba
babaaaaabaaa -> abaaaaabaaba

# < a,b | babaaaaababaaa=a >
babaaaaababaaa -> a
babaaaaaa -> aaababaaa

# < a,b | babaaaaababbaa=a >
babaaaaababbaa -> a

# < a,b | babaaaaabbaaaa=a >
babaaaaabbaaaa -> a

# < a,b | babaaaaabbaaba=a >
babaaaaabbaaba -> a
babaaaaabbaaa -> abaaaaabbaaba

# < a,b | babaaaaabbbaaa=a >
babaaaaabbbaaa -> a

# < a,b | babaaaaabbbbaa=a >
babaaaaabbbbaa -> a

# < a,b | babaaaaabbbbba=a >
babaaaaabbbbba -> a
babaaaaabbbba -> abaaaaabbbbba
babaaaaabbba -> abaaaaabbbba
babaaaaabba -> abaaaaabbba
babaaaaaba -> abaaaaabba
babaaaaaa -> abaaaaaba

# < a,b | babaaaabaaaaaa=a >
babaaaabaaaaaa -> a

# < a,b | babaaaabaaaaba=a >
babaaaabaaaaba -> a
babaaaabaaaaa -> abaaaabaaaaba

# < a,b | babaaaabaaabaa=a >
babaaaabaaabaa -> a

# < a,b | babaaaabaaabba=a >
babaaaabaaabba -> a
babaaaabaaaba -> abaaaabaaabba
babaaaabaaaa -> abaaaabaaaba

# < a,b | babaaaabaabaaa=a >
babaaaabaabaaa -> a

# < a,b | babaaaabaababa=a >
babaaaabaababa -> a
babaaaabaabaa -> abaaaabaababa
babaaaabaaa -> aaaabaababa

# < a,b | babaaaabaabbaa=a >
babaaaabaabbaa -> a

# < a,b | babaaaabaabbba=a >
babaaaabaabbba -> a
babaaaabaabba -> abaaaabaabbba
babaaaabaaba -> abaaaabaabba
babaaaabaaa -> abaaaabaaba

# < a,b | babaaaababaaaa=a >
babaaaababaaaa -> a
babaaaaa -> ababaaaa

# < a,b | babaaaabababaa=a >
babaaaabababaa -> a
babaaaabaa -> aaabababaa

# < a,b | babaaaababbaaa=a >
babaaaababbaaa -> a

# < a,b | babaaaababbaba=a >
babaaaababbaba -> a
babaaaababbaa -> abaaaababbaba
babaaaababa -> aaaababbaba
babaaaabaa -> aaaababbaa
babaaaaa -> aaaababa

# < a,b | babaaaababbbaa=a >
babaaaababbbaa -> a

# < a,b | babaaaabbaaaaa=a >
babaaaabbaaaaa -> a

# < a,b | babaaaabbaaaba=a >
babaaaabbaaaba -> a
babaaaabbaaaa -> abaaaabbaaaba

# < a,b | babaaaabbaabaa=a >
babaaaabbaabaa -> a

# < a,b | babaaaabbaabba=a >
babaaaabbaabba -> a
babaaaabbaaba -> abaaaabbaabba
babaaaabbaaa -> abaaaabbaaba

# < a,b | babaaaabbabbaa=a >
babaaaabbabbaa -> a

# < a,b | babaaaabbbaaaa=a >
babaaaabbbaaaa -> a

# < a,b | babaaaabbbaaba=a >
babaaaabbbaaba -> a
babaaaabbbaaa -> abaaaabbbaaba

# < a,b | babaaaabbbbaaa=a >
babaaaabbbbaaa -> a

# < a,b | babaaaabbbbbaa=a >
babaaaabbbbbaa -> a

# < a,b | babaaaabbbbbba=a >
babaaaabbbbbba -> a
babaaaabbbbba -> abaaaabbbbbba
babaaaabbbba -> abaaaabbbbba
babaaaabbba -> abaaaabbbba
babaaaabba -> abaaaabbba
babaaaaba -> abaaaabba
babaaaaa -> abaaaaba

# < a,b | babaaabaaaaaaa=a >
babaaabaaaaaaa -> a

# < a,b | babaaabaaaaaba=a >
babaaabaaaaaba -> a
babaaabaaaaaa -> abaaabaaaaaba

# < a,b | babaaabaaaabaa=a >
babaaabaaaabaa -> a

# < a,b | babaaabaaaabba=a >
babaaabaaaabba -> a
babaaabaaaaba -> abaaabaaaabba
babaaabaaaaa -> abaaabaaaaba

# < a,b | babaaabaaabaaa=a >
babaaabaaabaaa -> a

# < a,b | babaaabaaababa=a >
babaaabaaababa -> a
babaaabaaabaa -> abaaabaaababa
babaaabaaaa -> aaabaaababa

# < a,b | babaaabaaabbaa=a >
babaaabaaabbaa -> a

# < a,b | babaaabaaabbba=a >
babaaabaaabbba -> a
babaaabaaabba -> abaaabaaabbba
babaaabaaaba -> abaaabaaabba
babaaabaaaa -> abaaabaaaba

# < a,b | babaaabaabaaaa=a >
babaaabaabaaaa -> a

# < a,b | babaaabaabaaba=a >
babaaabaabaaba -> a
babaaabaabaaa -> abaaabaabaaba

# < a,b | babaaabaababaa=a >
babaaabaababaa -> a
babaaabaaa -> aabaababaa

# < a,b | babaaabaabbaaa=a >
babaaabaabbaaa -> a

# < a,b | babaaabaabbaba=a >
babaaabaabbaba -> a
babaaabaabbaa -> abaaabaabbaba
babaaabaaba -> aaabaabbaba
babaaabaaa -> aaabaabbaa

# < a,b | babaaabaabbbaa=a >
babaaabaabbbaa -> a

# < a,b | babaaabaabbbba=a >
babaaabaabbbba -> a
babaaabaabbba -> abaaabaabbbba
babaaabaabba -> abaaabaabbba
babaaabaaba -> abaaabaabba
babaaabaaa -> abaaabaaba

# < a,b | babaaababaaaaa=a >
babaaababaaaaa -> a

# < a,b | babaaababaaaba=a >
babaaababaaaba -> a
babaaaa -> abaaaba

# < a,b | babaaababaabaa=a >
babaaababaabaa -> a

# < a,b | babaaabababaaa=a >
babaaabababaaa -> a
babaaabaa -> abababaaa

# < a,b | babaaabababbaa=a >
babaaabababbaa -> a

# < a,b | babaaababbaaaa=a >
babaaababbaaaa -> a

# < a,b | babaaababbaaba=a >
babaaababbaaba -> a
babaaababbaaa -> abaaababbaaba

# < a,b | babaaababbbaaa=a >
babaaababbbaaa -> a

# < a,b | babaaababbbbaa=a >
babaaababbbbaa -> a

# < a,b | babaaabbaaaaaa=a >
babaaabbaaaaaa -> a

# < a,b | babaaabbaaaaba=a >
babaaabbaaaaba -> a
babaaabbaaaaa -> abaaabbaaaaba

# < a,b | babaaabbaaabaa=a >
babaaabbaaabaa -> a

# < a,b | babaaabbaaabba=a >
babaaabbaaabba -> a
babaaabbaaaba -> abaaabbaaabba
babaaabbaaaa -> abaaabbaaaba

# < a,b | babaaabbaabaaa=a >
babaaabbaabaaa -> a

# < a,b | babaaabbaababa=a >
babaaabbaababa -> a
babaaabbaabaa -> abaaabbaababa
babaaabbaaa -> aaabbaababa

# < a,b | babaaabbaabbaa=a >
babaaabbaabbaa -> a

# < a,b | babaaabbaabbba=a >
babaaabbaabbba -> a
babaaabbaabba -> abaaabbaabbba
babaaabbaaba -> abaaabbaabba
babaaabbaaa -> abaaabbaaba

# < a,b | babaaabbabaaaa=a >
babaaabbabaaaa -> a

# < a,b | babaaabbababaa=a >
babaaabbababaa -> a
babaaabbaa -> aabbababaa

# < a,b | babaaabbabbaaa=a >
babaaabbabbaaa -> a

# < a,b | babaaabbabbaba=a >
babaaabbabbaba -> a
babaaabbabbaa -> abaaabbabbaba
babaaabbaba -> aaabbabbaba
babaaabbaa -> aaabbabbaa
babaaaba -> aaabbaba
babaaaa -> aaabbaa

# < a,b | babaaabbabbbaa=a >
babaaabbabbbaa -> a

# < a,b | babaaabbbaaaaa=a >
babaaabbbaaaaa -> a

# < a,b | babaaabbbaaaba=a >
babaaabbbaaaba -> a
babaaabbbaaaa -> abaaabbbaaaba

# < a,b | babaaabbbaabaa=a >
babaaabbbaabaa -> a

# < a,b | babaaabbbaabba=a >
babaaabbbaabba -> a
babaaabbbaaba -> abaaabbbaabba
babaaabbbaaa -> abaaabbbaaba

# < a,b | babaaabbbabbaa=a >
babaaabbbabbaa -> a

# < a,b | babaaabbbbaaaa=a >
babaaabbbbaaaa -> a

# < a,b | babaaabbbbaaba=a >
babaaabbbbaaba -> a
babaaabbbbaaa -> abaaabbbbaaba

# < a,b | babaaabbbbbaaa=a >
babaaabbbbbaaa -> a

# < a,b | babaaabbbbbbaa=a >
babaaabbbbbbaa -> a

# < a,b | babaaabbbbbbba=a >
babaaabbbbbbba -> a
babaaabbbbbba -> abaaabbbbbbba
babaaabbbbba -> abaaabbbbbba
babaaabbbba -> abaaabbbbba
babaaabbba -> abaaabbbba
babaaabba -> abaaabbba
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaaaaaaa=a >
babaabaaaaaaaa -> a

# < a,b | babaabaaaaaaba=a >
babaabaaaaaaba -> a
babaabaaaaaaa -> abaabaaaaaaba

# < a,b | babaabaaaaabaa=a >
babaabaaaaabaa -> a

# < a,b | babaabaaaaabba=a >
babaabaaaaabba -> a
babaabaaaaaba -> abaabaaaaabba
babaabaaaaaa -> abaabaaaaaba

# < a,b | babaabaaaabaaa=a >
babaabaaaabaaa -> a

# < a,b | babaabaaaababa=a >
babaabaaaababa -> a
babaabaaaabaa -> abaabaaaababa
babaabaaaaa -> aabaaaababa

# < a,b | babaabaaaabbaa=a >
babaabaaaabbaa -> a

# < a,b | babaabaaaabbba=a >
babaabaaaabbba -> a
babaabaaaabba -> abaabaaaabbba
babaabaaaaba -> abaabaaaabba
babaabaaaaa -> abaabaaaaba

# < a,b | babaabaaabaaaa=a >
babaabaaabaaaa -> a

# < a,b | babaabaaabaaba=a >
babaabaaabaaba -> a
babaabaaabaaa -> abaabaaabaaba

# < a,b | babaabaaababaa=a >
babaabaaababaa -> a
babaabaaaa -> abaaababaa

# < a,b | babaabaaabbaaa=a >
babaabaaabbaaa -> a

# < a,b | babaabaaabbaba=a >
babaabaaabbaba -> a
babaabaaabbaa -> abaabaaabbaba
babaabaaaba -> aabaaabbaba
babaabaaaa -> aabaaabbaa

# < a,b | babaabaaabbbaa=a >
babaabaaabbbaa -> a

# < a,b | babaabaaabbbba=a >
babaabaaabbbba -> a
babaabaaabbba -> abaabaaabbbba
babaabaaabba -> abaabaaabbba
babaabaaaba -> abaabaaabba
babaabaaaa -> abaabaaaba

# < a,b | babaabaabaaaaa=a >
babaabaabaaaaa -> a

# < a,b | babaabaabaaaba=a >
babaabaabaaaba -> a
babaabaabaaaa -> abaabaabaaaba

# < a,b | babaabaabaabaa=a >
babaabaabaabaa -> a

# < a,b | babaabaabaabba=a >
babaabaabaabba -> a
babaabaabaaba -> abaabaabaabba
babaabaabaaa -> abaabaabaaba

# < a,b | babaabaababaaa=a >
babaabaababaaa -> a

# < a,b | babaabaababbaa=a >
babaabaababbaa -> a

# < a,b | babaabaabbaaaa=a >
babaabaabbaaaa -> a

# < a,b | babaabaabbaaba=a >
babaabaabbaaba -> a
babaabaabbaaa -> abaabaabbaaba

# < a,b | babaabaabbbaaa=a >
babaabaabbbaaa -> a

# < a,b | babaabaabbbbaa=a >
babaabaabbbbaa -> a

# < a,b | babaabaabbbbba=a >
babaabaabbbbba -> a
babaabaabbbba -> abaabaabbbbba
babaabaabbba -> abaabaabbbba
babaabaabba -> abaabaabbba
babaabaaba -> abaabaabba
babaabaaa -> abaabaaba

# < a,b | babaababaaaaaa=a >
babaababaaaaaa -> a

# < a,b | babaababaaaaba=a >
babaababaaaaba -> a
babaababaaaaa -> abaababaaaaba

# < a,b | babaababaaabaa=a >
babaababaaabaa -> a

# < a,b | babaababaaabba=a >
babaababaaabba -> a
babaababaaaba -> abaababaaabba
babaababaaaa -> abaababaaaba

# < a,b | babaababaabaaa=a >
babaababaabaaa -> a

# < a,b | babaababaababa=a >
babaababaababa -> a
babaababaabaa -> abaababaababa
babaaa -> aababa

# < a,b | babaababaabbaa=a >
babaababaabbaa -> a

# < a,b | babaabababaaaa=a >
babaabababaaaa -> a

# < a,b | babaabababaaba=a >
babaabababaaba -> a
babaabababaaa -> abaabababaaba
babaabaa -> ababaaba

# < a,b | babaababababaa=a >
babaababababaa -> a
babaababaa -> ababababaa
babaaa -> ababaa

# < a,b | babaabababbaaa=a >
babaabababbaaa -> a

# < a,b | babaabababbbaa=a >
babaabababbbaa -> a

# < a,b | babaababbaaaaa=a >
babaababbaaaaa -> a

# < a,b | babaababbaaaba=a >
babaababbaaaba -> a
babaababbaaaa -> abaababbaaaba

# < a,b | babaababbaabaa=a >
babaababbaabaa -> a

# < a,b | babaababbaabba=a >
babaababbaabba -> a
babaababbaaba -> abaababbaabba
babaababbaaa -> abaababbaaba

# < a,b | babaababbabaaa=a >
babaababbabaaa -> a

# < a,b | babaababbabbaa=a >
babaababbabbaa -> a

# < a,b | babaababbbaaaa=a >
babaababbbaaaa -> a

# < a,b | babaababbbaaba=a >
babaababbbaaba -> a
babaababbbaaa -> abaababbbaaba

# < a,b | babaababbbbaaa=a >
babaababbbbaaa -> a

# < a,b | babaababbbbbaa=a >
babaababbbbbaa -> a

# < a,b | babaabbaaaaaaa=a >
babaabbaaaaaaa -> a

# < a,b | babaabbaaaaaba=a >
babaabbaaaaaba -> a
babaabbaaaaaa -> abaabbaaaaaba

# < a,b | babaabbaaaabaa=a >
babaabbaaaabaa -> a

# < a,b | babaabbaaaabba=a >
babaabbaaaabba -> a
babaabbaaaaba -> abaabbaaaabba
babaabbaaaaa -> abaabbaaaaba

# < a,b | babaabbaaabaaa=a >
babaabbaaabaaa -> a

# < a,b | babaabbaaababa=a >
babaabbaaababa -> a
babaabbaaabaa -> abaabbaaababa
babaabbaaaa -> aabbaaababa

# < a,b | babaabbaaabbaa=a >
babaabbaaabbaa -> a

# < a,b | babaabbaaabbba=a >
babaabbaaabbba -> a
babaabbaaabba -> abaabbaaabbba
babaabbaaaba -> abaabbaaabba
babaabbaaaa -> abaabbaaaba

# < a,b | babaabbaabaaaa=a >
babaabbaabaaaa -> a

# < a,b | babaabbaabaaba=a >
babaabbaabaaba -> a
babaabbaabaaa -> abaabbaabaaba

# < a,b | babaabbaababaa=a >
babaabbaababaa -> a
babaabbaaa -> abbaababaa

# < a,b | babaabbaabbaaa=a >
babaabbaabbaaa -> a

# < a,b | babaabbaabbaba=a >
babaabbaabbaba -> a
babaabbaabbaa -> abaabbaabbaba
babaabbaaba -> aabbaabbaba
babaabbaaa -> aabbaabbaa

# < a,b | babaabbaabbbaa=a >
babaabbaabbbaa -> a

# < a,b | babaabbaabbbba=a >
babaabbaabbbba -> a
babaabbaabbba -> abaabbaabbbba
babaabbaabba -> abaabbaabbba
babaabbaaba -> abaabbaabba
babaabbaaa -> abaabbaaba

# < a,b | babaabbabaaaaa=a >
babaabbabaaaaa -> a

# < a,b | babaabbabaaaba=a >
babaabbabaaaba -> a
babaabbabaaaa -> abaabbabaaaba

# < a,b | babaabbabaabaa=a >
babaabbabaabaa -> a

# < a,b | babaabbabaabba=a >
babaabbabaabba -> a
babaaba -> abaabba
babaaa -> abaaba

# < a,b | babaabbababaaa=a >
babaabbababaaa -> a

# < a,b | babaabbababbaa=a >
babaabbababbaa -> a

# < a,b | babaabbabbaaaa=a >
babaabbabbaaaa -> a

# < a,b | babaabbabbaaba=a >
babaabbabbaaba -> a
babaabbabbaaa -> abaabbabbaaba

# < a,b | babaabbabbbaaa=a >
babaabbabbbaaa -> a

# < a,b | babaabbabbbbaa=a >
babaabbabbbbaa -> a

# < a,b | babaabbbaaaaaa=a >
babaabbbaaaaaa -> a

# < a,b | babaabbbaaaaba=a >
babaabbbaaaaba -> a
babaabbbaaaaa -> abaabbbaaaaba

# < a,b | babaabbbaaabaa=a >
babaabbbaaabaa -> a

# < a,b | babaabbbaaabba=a >
babaabbbaaabba -> a
babaabbbaaaba -> abaabbbaaabba
babaabbbaaaa -> abaabbbaaaba

# < a,b | babaabbbaabaaa=a >
babaabbbaabaaa -> a

# < a,b | babaabbbaababa=a >
babaabbbaababa -> a
babaabbbaabaa -> abaabbbaababa
babaabbbaaa -> aabbbaababa

# < a,b | babaabbbaabbaa=a >
babaabbbaabbaa -> a

# < a,b | babaabbbaabbba=a >
babaabbbaabbba -> a
babaabbbaabba -> abaabbbaabbba
babaabbbaaba -> abaabbbaabba
babaabbbaaa -> abaabbbaaba

# < a,b | babaabbbabaaaa=a >
babaabbbabaaaa -> a

# < a,b | babaabbbabaaba=a >
babaabbbabaaba -> a
babaabbbabaaa -> abaabbbabaaba

# < a,b | babaabbbababaa=a >
babaabbbababaa -> a
babaabbbaa -> abbbababaa

# < a,b | babaabbbabbaaa=a >
babaabbbabbaaa -> a

# < a,b | babaabbbabbbaa=a >
babaabbbabbbaa -> a

# < a,b | babaabbbbaaaaa=a >
babaabbbbaaaaa -> a

# < a,b | babaabbbbaaaba=a >
babaabbbbaaaba -> a
babaabbbbaaaa -> abaabbbbaaaba

# < a,b | babaabbbbaabaa=a >
babaabbbbaabaa -> a

# < a,b | babaabbbbaabba=a >
babaabbbbaabba -> a
babaabbbbaaba -> abaabbbbaabba
babaabbbbaaa -> abaabbbbaaba

# < a,b | babaabbbbabaaa=a >
babaabbbbabaaa -> a

# < a,b | babaabbbbabbaa=a >
babaabbbbabbaa -> a

# < a,b | babaabbbbbaaaa=a >
babaabbbbbaaaa -> a

# < a,b | babaabbbbbaaba=a >
babaabbbbbaaba -> a
babaabbbbbaaa -> abaabbbbbaaba

# < a,b | babaabbbbbbaaa=a >
babaabbbbbbaaa -> a

# < a,b | babaabbbbbbbaa=a >
babaabbbbbbbaa -> a

# < a,b | babaabbbbbbbba=a >
babaabbbbbbbba -> a
babaabbbbbbba -> abaabbbbbbbba
babaabbbbbba -> abaabbbbbbba
babaabbbbba -> abaabbbbbba
babaabbbba -> abaabbbbba
babaabbba -> abaabbbba
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaaaaaaa=a >
bababaaaaaaaaa -> a

# < a,b | bababaaaaaaaba=a >
bababaaaaaaaba -> a
bababaaaaaaaa -> ababaaaaaaaba

# < a,b | bababaaaaaabaa=a >
bababaaaaaabaa -> a

# < a,b | bababaaaaaabba=a >
bababaaaaaabba -> a
bababaaaaaaba -> ababaaaaaabba
bababaaaaaaa -> ababaaaaaaba

# < a,b | bababaaaaabaaa=a >
bababaaaaabaaa -> a

# < a,b | bababaaaaababa=a >
bababaaaaababa -> a
bababaaaaabaa -> ababaaaaababa
bababaaaaaa -> abaaaaababa

# < a,b | bababaaaaabbaa=a >
bababaaaaabbaa -> a

# < a,b | bababaaaaabbba=a >
bababaaaaabbba -> a
bababaaaaabba -> ababaaaaabbba
bababaaaaaba -> ababaaaaabba
bababaaaaaa -> ababaaaaaba

# < a,b | bababaaaabaaaa=a >
bababaaaabaaaa -> a

# < a,b | bababaaaabaaba=a >
bababaaaabaaba -> a
bababaaaabaaa -> ababaaaabaaba

# < a,b | bababaaaababaa=a >
bababaaaababaa -> a

# < a,b | bababaaaabbaaa=a >
bababaaaabbaaa -> a

# < a,b | bababaaaabbaba=a >
bababaaaabbaba -> a
bababaaaabbaa -> ababaaaabbaba
bababaaaaba -> abaaaabbaba
bababaaaaa -> abaaaabbaa

# < a,b | bababaaaabbbaa=a >
bababaaaabbbaa -> a

# < a,b | bababaaaabbbba=a >
bababaaaabbbba -> a
bababaaaabbba -> ababaaaabbbba
bababaaaabba -> ababaaaabbba
bababaaaaba -> ababaaaabba
bababaaaaa -> ababaaaaba

# < a,b | bababaaabaaaaa=a >
bababaaabaaaaa -> a

# < a,b | bababaaabaaaba=a >
bababaaabaaaba -> a
bababaaabaaaa -> ababaaabaaaba

# < a,b | bababaaabaabaa=a >
bababaaabaabaa -> a

# < a,b | bababaaabaabba=a >
bababaaabaabba -> a
bababaaabaaba -> ababaaabaabba
bababaaabaaa -> ababaaabaaba

# < a,b | bababaaababaaa=a >
bababaaababaaa -> a

# < a,b | bababaaabababa=a >
bababaaabababa -> a
bababaaababaa -> ababaaabababa
bababaaabaa -> abaaabababa
bababaaaa -> aaabababa

# < a,b | bababaaababbaa=a >
bababaaababbaa -> a

# < a,b | bababaaabbaaaa=a >
bababaaabbaaaa -> a

# < a,b | bababaaabbaaba=a >
bababaaabbaaba -> a
bababaaabbaaa -> ababaaabbaaba

# < a,b | bababaaabbabaa=a >
bababaaabbabaa -> a

# < a,b | bababaaabbbaaa=a >
bababaaabbbaaa -> a

# < a,b | bababaaabbbbaa=a >
bababaaabbbbaa -> a

# < a,b | bababaaabbbbba=a >
bababaaabbbbba -> a
bababaaabbbba -> ababaaabbbbba
bababaaabbba -> ababaaabbbba
bababaaabba -> ababaaabbba
bababaaaba -> ababaaabba
bababaaaa -> ababaaaba

# < a,b | bababaabaaaaaa=a >
bababaabaaaaaa -> a

# < a,b | bababaabaaaaba=a >
bababaabaaaaba -> a
bababaabaaaaa -> ababaabaaaaba

# < a,b | bababaabaaabaa=a >
bababaabaaabaa -> a

# < a,b | bababaabaaabba=a >
bababaabaaabba -> a
bababaabaaaba -> ababaabaaabba
bababaabaaaa -> ababaabaaaba

# < a,b | bababaabaabaaa=a >
bababaabaabaaa -> a

# < a,b | bababaabaababa=a >
bababaabaababa -> a
bababaabaabaa -> ababaabaababa
bababaabaaa -> abaabaababa

# < a,b | bababaabaabbaa=a >
bababaabaabbaa -> a

# < a,b | bababaabaabbba=a >
bababaabaabbba -> a
bababaabaabba -> ababaabaabbba
bababaabaaba -> ababaabaabba
bababaabaaa -> ababaabaaba

# < a,b | bababaababaaaa=a >
bababaababaaaa -> a

# < a,b | bababaababaaba=a >
bababaababaaba -> a
bababaababaaa -> ababaababaaba

# < a,b | bababaabababaa=a >
bababaabababaa -> a
bababaaa -> abababaa

# < a,b | bababaababbaaa=a >
bababaababbaaa -> a

# < a,b | bababaababbaba=a >
bababaababbaba -> a
bababaababbaa -> ababaababbaba
bababaababa -> abaababbaba
bababaabaa -> abaababbaa
bababaaa -> abaababa

# < a,b | bababaababbbaa=a >
bababaababbbaa -> a

# < a,b | bababaabbaaaaa=a >
bababaabbaaaaa -> a

# < a,b | bababaabbaaaba=a >
bababaabbaaaba -> a
bababaabbaaaa -> ababaabbaaaba

# < a,b | bababaabbaabaa=a >
bababaabbaabaa -> a

# < a,b | bababaabbaabba=a >
bababaabbaabba -> a
bababaabbaaba -> ababaabbaabba
bababaabbaaa -> ababaabbaaba

# < a,b | bababaabbabaaa=a >
bababaabbabaaa -> a

# < a,b | bababaabbababa=a >
bababaabbababa -> a
bababaabbabaa -> ababaabbababa
bababaabbaa -> abaabbababa
bababaaba -> aabbababa
bababaaa -> aabbabaa

# < a,b | bababaabbabbaa=a >
bababaabbabbaa -> a

# < a,b | bababaabbbaaaa=a >
bababaabbbaaaa -> a

# < a,b | bababaabbbaaba=a >
bababaabbbaaba -> a
bababaabbbaaa -> ababaabbbaaba

# < a,b | bababaabbbabaa=a >
bababaabbbabaa -> a

# < a,b | bababaabbbbaaa=a >
bababaabbbbaaa -> a

# < a,b | bababaabbbbbaa=a >
bababaabbbbbaa -> a

# < a,b | bababaabbbbbba=a >
bababaabbbbbba -> a
bababaabbbbba -> ababaabbbbbba
bababaabbbba -> ababaabbbbba
bababaabbba -> ababaabbbba
bababaabba -> ababaabbba
bababaaba -> ababaabba
bababaaa -> ababaaba

# < a,b | babababaaaaaaa=a >
babababaaaaaaa -> a

# < a,b | babababaaaaaba=a >
babababaaaaaba -> a
babababaaaaaa -> abababaaaaaba

# < a,b | babababaaaabaa=a >
babababaaaabaa -> a

# < a,b | babababaaaabba=a >
babababaaaabba -> a
babababaaaaba -> abababaaaabba
babababaaaaa -> abababaaaaba

# < a,b | babababaaabaaa=a >
babababaaabaaa -> a

# < a,b | babababaaababa=a >
babababaaababa -> a
babababaaabaa -> abababaaababa
babababaaaa -> ababaaababa

# < a,b | babababaaabbaa=a >
babababaaabbaa -> a

# < a,b | babababaaabbba=a >
babababaaabbba -> a
babababaaabba -> abababaaabbba
babababaaaba -> abababaaabba
babababaaaa -> abababaaaba

# < a,b | babababaabaaaa=a >
babababaabaaaa -> a

# < a,b | babababaabaaba=a >
babababaabaaba -> a
babababaabaaa -> abababaabaaba

# < a,b | babababaababaa=a >
babababaababaa -> a

# < a,b | babababaabbaaa=a >
babababaabbaaa -> a

# < a,b | babababaabbaba=a >
babababaabbaba -> a
babababaabbaa -> abababaabbaba
babababaaba -> ababaabbaba
babababaaa -> ababaabbaa

# < a,b | babababaabbbaa=a >
babababaabbbaa -> a

# < a,b | babababaabbbba=a >
babababaabbbba -> a
babababaabbba -> abababaabbbba
babababaabba -> abababaabbba
babababaaba -> abababaabba
babababaaa -> abababaaba

# < a,b | bababababaaaaa=a >
bababababaaaaa -> a

# < a,b | bababababaaaba=a >
bababababaaaba -> a
bababababaaaa -> ababababaaaba

# < a,b | bababababaabaa=a >
bababababaabaa -> a

# < a,b | bababababaabba=a >
bababababaabba -> a
bababababaaba -> ababababaabba
bababababaaa -> ababababaaba

# < a,b | babababababaaa=a >
babababababaaa -> a

# < a,b | bababababababa=a >
bababababababa -> a
baa -> aba

# < a,b | babababababbaa=a >
babababababbaa -> a

# < a,b | bababababbaaaa=a >
bababababbaaaa -> a

# < a,b | bababababbaaba=a >
bababababbaaba -> a
bababababbaaa -> ababababbaaba

# < a,b | bababababbabaa=a >
bababababbabaa -> a

# < a,b | bababababbbaaa=a >
bababababbbaaa -> a

# < a,b | bababababbbbaa=a >
bababababbbbaa -> a

# < a,b | babababbaaaaaa=a >
babababbaaaaaa -> a

# < a,b | babababbaaaaba=a >
babababbaaaaba -> a
babababbaaaaa -> abababbaaaaba

# < a,b | babababbaaabaa=a >
babababbaaabaa -> a

# < a,b | babababbaaabba=a >
babababbaaabba -> a
babababbaaaba -> abababbaaabba
babababbaaaa -> abababbaaaba

# < a,b | babababbaabaaa=a >
babababbaabaaa -> a

# < a,b | babababbaababa=a >
babababbaababa -> a
babababbaabaa -> abababbaababa
babababbaaa -> ababbaababa

# < a,b | babababbaabbaa=a >
babababbaabbaa -> a

# < a,b | babababbaabbba=a >
babababbaabbba -> a
babababbaabba -> abababbaabbba
babababbaaba -> abababbaabba
babababbaaa -> abababbaaba

# < a,b | babababbabaaaa=a >
babababbabaaaa -> a

# < a,b | babababbabaaba=a >
babababbabaaba -> a
babababbabaaa -> abababbabaaba

# < a,b | babababbababaa=a >
babababbababaa -> a

# < a,b | babababbabbaaa=a >
babababbabbaaa -> a

# < a,b | babababbabbbaa=a >
babababbabbbaa -> a

# < a,b | babababbbaaaaa=a >
babababbbaaaaa -> a

# < a,b | babababbbaaaba=a >
babababbbaaaba -> a
babababbbaaaa -> abababbbaaaba

# < a,b | babababbbaabaa=a >
babababbbaabaa -> a

# < a,b | babababbbaabba=a >
babababbbaabba -> a
babababbbaaba -> abababbbaabba
babababbbaaa -> abababbbaaba

# < a,b | babababbbabaaa=a >
babababbbabaaa -> a

# < a,b | babababbbabbaa=a >
babababbbabbaa -> a

# < a,b | babababbbbaaaa=a >
babababbbbaaaa -> a

# < a,b | babababbbbaaba=a >
babababbbbaaba -> a
babababbbbaaa -> abababbbbaaba

# < a,b | babababbbbabaa=a >
babababbbbabaa -> a

# < a,b | babababbbbbaaa=a >
babababbbbbaaa -> a

# < a,b | babababbbbbbaa=a >
babababbbbbbaa -> a

# < a,b | bababbaaaaaaaa=a >
bababbaaaaaaaa -> a

# < a,b | bababbaaaaaaba=a >
bababbaaaaaaba -> a
bababbaaaaaaa -> ababbaaaaaaba

# < a,b | bababbaaaaabaa=a >
bababbaaaaabaa -> a

# < a,b | bababbaaaaabba=a >
bababbaaaaabba -> a
bababbaaaaaba -> ababbaaaaabba
bababbaaaaaa -> ababbaaaaaba

# < a,b | bababbaaaabaaa=a >
bababbaaaabaaa -> a

# < a,b | bababbaaaababa=a >
bababbaaaababa -> a
bababbaaaabaa -> ababbaaaababa
bababbaaaaa -> abbaaaababa

# < a,b | bababbaaaabbaa=a >
bababbaaaabbaa -> a

# < a,b | bababbaaaabbba=a >
bababbaaaabbba -> a
bababbaaaabba -> ababbaaaabbba
bababbaaaaba -> ababbaaaabba
bababbaaaaa -> ababbaaaaba

# < a,b | bababbaaabaaaa=a >
bababbaaabaaaa -> a

# < a,b | bababbaaabaaba=a >
bababbaaabaaba -> a
bababbaaabaaa -> ababbaaabaaba

# < a,b | bababbaaababaa=a >
bababbaaababaa -> a

# < a,b | bababbaaabbaaa=a >
bababbaaabbaaa -> a

# < a,b | bababbaaabbaba=a >
bababbaaabbaba -> a
bababbaaabbaa -> ababbaaabbaba
bababbaaaba -> abbaaabbaba
bababbaaaa -> abbaaabbaa

# < a,b | bababbaaabbbaa=a >
bababbaaabbbaa -> a

# < a,b | bababbaaabbbba=a >
bababbaaabbbba -> a
bababbaaabbba -> ababbaaabbbba
bababbaaabba -> ababbaaabbba
bababbaaaba -> ababbaaabba
bababbaaaa -> ababbaaaba

# < a,b | bababbaabaaaaa=a >
bababbaabaaaaa -> a

# < a,b | bababbaabaaaba=a >
bababbaabaaaba -> a
bababbaabaaaa -> ababbaabaaaba

# < a,b | bababbaabaabaa=a >
bababbaabaabaa -> a

# < a,b | bababbaabaabba=a >
bababbaabaabba -> a
bababbaabaaba -> ababbaabaabba
bababbaabaaa -> ababbaabaaba

# < a,b | bababbaababaaa=a >
bababbaababaaa -> a

# < a,b | bababbaabababa=a >
bababbaabababa -> a
bababbaababaa -> ababbaabababa
bababbaabaa -> abbaabababa

# < a,b | bababbaababbaa=a >
bababbaababbaa -> a

# < a,b | bababbaabbaaaa=a >
bababbaabbaaaa -> a

# < a,b | bababbaabbaaba=a >
bababbaabbaaba -> a
bababbaabbaaa -> ababbaabbaaba

# < a,b | bababbaabbabaa=a >
bababbaabbabaa -> a

# < a,b | bababbaabbbaaa=a >
bababbaabbbaaa -> a

# < a,b | bababbaabbbbaa=a >
bababbaabbbbaa -> a

# < a,b | bababbaabbbbba=a >
bababbaabbbbba -> a
bababbaabbbba -> ababbaabbbbba
bababbaabbba -> ababbaabbbba
bababbaabba -> ababbaabbba
bababbaaba -> ababbaabba
bababbaaa -> ababbaaba

# < a,b | bababbabaaaaaa=a >
bababbabaaaaaa -> a

# < a,b | bababbabaaaaba=a >
bababbabaaaaba -> a
bababbabaaaaa -> ababbabaaaaba

# < a,b | bababbabaaabaa=a >
bababbabaaabaa -> a

# < a,b | bababbabaaabba=a >
bababbabaaabba -> a
bababbabaaaba -> ababbabaaabba
bababbabaaaa -> ababbabaaaba

# < a,b | bababbabaabaaa=a >
bababbabaabaaa -> a

# < a,b | bababbabaababa=a >
bababbabaababa -> a
bababbabaabaa -> ababbabaababa
bababbabaaa -> abbabaababa

# < a,b | bababbabaabbaa=a >
bababbabaabbaa -> a

# < a,b | bababbabaabbba=a >
bababbabaabbba -> a
bababbabaabba -> ababbabaabbba
bababbabaaba -> ababbabaabba
bababbabaaa -> ababbabaaba

# < a,b | bababbababaaaa=a >
bababbababaaaa -> a

# < a,b | bababbababaaba=a >
bababbababaaba -> a
bababbababaaa -> ababbababaaba

# < a,b | bababbabababaa=a >
bababbabababaa -> a

# < a,b | bababbababbaaa=a >
bababbababbaaa -> a

# < a,b | bababbababbaba=a >
bababbababbaba -> a
bababa -> abbaba
baa -> aba

# < a,b | bababbababbbaa=a >
bababbababbbaa -> a

# < a,b | bababbabbaaaaa=a >
bababbabbaaaaa -> a

# < a,b | bababbabbaaaba=a >
bababbabbaaaba -> a
bababbabbaaaa -> ababbabbaaaba

# < a,b | bababbabbaabaa=a >
bababbabbaabaa -> a

# < a,b | bababbabbaabba=a >
bababbabbaabba -> a
bababbabbaaba -> ababbabbaabba
bababbabbaaa -> ababbabbaaba

# < a,b | bababbabbabaaa=a >
bababbabbabaaa -> a

# < a,b | bababbabbababa=a >
bababbabbababa -> a
bababbabbabaa -> ababbabbababa
bababbabbaa -> abbabbababa

# < a,b | bababbabbabbaa=a >
bababbabbabbaa -> a

# < a,b | bababbabbbaaaa=a >
bababbabbbaaaa -> a

# < a,b | bababbabbbaaba=a >
bababbabbbaaba -> a
bababbabbbaaa -> ababbabbbaaba

# < a,b | bababbabbbabaa=a >
bababbabbbabaa -> a

# < a,b | bababbabbbbaaa=a >
bababbabbbbaaa -> a

# < a,b | bababbabbbbbaa=a >
bababbabbbbbaa -> a

# < a,b | bababbbaaaaaaa=a >
bababbbaaaaaaa -> a

# < a,b | bababbbaaaaaba=a >
bababbbaaaaaba -> a
bababbbaaaaaa -> ababbbaaaaaba

# < a,b | bababbbaaaabaa=a >
bababbbaaaabaa -> a

# < a,b | bababbbaaaabba=a >
bababbbaaaabba -> a
bababbbaaaaba -> ababbbaaaabba
bababbbaaaaa -> ababbbaaaaba

# < a,b | bababbbaaabaaa=a >
bababbbaaabaaa -> a

# < a,b | bababbbaaababa=a >
bababbbaaababa -> a
bababbbaaabaa -> ababbbaaababa
bababbbaaaa -> abbbaaababa

# < a,b | bababbbaaabbaa=a >
bababbbaaabbaa -> a

# < a,b | bababbbaaabbba=a >
bababbbaaabbba -> a
bababbbaaabba -> ababbbaaabbba
bababbbaaaba -> ababbbaaabba
bababbbaaaa -> ababbbaaaba

# < a,b | bababbbaabaaaa=a >
bababbbaabaaaa -> a

# < a,b | bababbbaabaaba=a >
bababbbaabaaba -> a
bababbbaabaaa -> ababbbaabaaba

# < a,b | bababbbaababaa=a >
bababbbaababaa -> a

# < a,b | bababbbaabbaaa=a >
bababbbaabbaaa -> a

# < a,b | bababbbaabbaba=a >
bababbbaabbaba -> a
bababbbaabbaa -> ababbbaabbaba
bababbbaaba -> abbbaabbaba
bababbbaaa -> abbbaabbaa

# < a,b | bababbbaabbbaa=a >
bababbbaabbbaa -> a

# < a,b | bababbbaabbbba=a >
bababbbaabbbba -> a
bababbbaabbba -> ababbbaabbbba
bababbbaabba -> ababbbaabbba
bababbbaaba -> ababbbaabba
bababbbaaa -> ababbbaaba

# < a,b | bababbbabaaaaa=a >
bababbbabaaaaa -> a

# < a,b | bababbbabaaaba=a >
bababbbabaaaba -> a
bababbbabaaaa -> ababbbabaaaba

# < a,b | bababbbabaabaa=a >
bababbbabaabaa -> a

# < a,b | bababbbabaabba=a >
bababbbabaabba -> a
bababbbabaaba -> ababbbabaabba
bababbbabaaa -> ababbbabaaba

# < a,b | bababbbababaaa=a >
bababbbababaaa -> a

# < a,b | bababbbabababa=a >
bababbbabababa -> a
bababbbababaa -> ababbbabababa
bababbbabaa -> abbbabababa

# < a,b | bababbbababbaa=a >
bababbbababbaa -> a

# < a,b | bababbbabbaaaa=a >
bababbbabbaaaa -> a

# < a,b | bababbbabbaaba=a >
bababbbabbaaba -> a
bababbbabbaaa -> ababbbabbaaba

# < a,b | bababbbabbabaa=a >
bababbbabbabaa -> a

# < a,b | bababbbabbbaaa=a >
bababbbabbbaaa -> a

# < a,b | bababbbabbbbaa=a >
bababbbabbbbaa -> a

# < a,b | bababbbbaaaaaa=a >
bababbbbaaaaaa -> a

# < a,b | bababbbbaaaaba=a >
bababbbbaaaaba -> a
bababbbbaaaaa -> ababbbbaaaaba

# < a,b | bababbbbaaabaa=a >
bababbbbaaabaa -> a

# < a,b | bababbbbaaabba=a >
bababbbbaaabba -> a
bababbbbaaaba -> ababbbbaaabba
bababbbbaaaa -> ababbbbaaaba

# < a,b | bababbbbaabaaa=a >
bababbbbaabaaa -> a

# < a,b | bababbbbaababa=a >
bababbbbaababa -> a
bababbbbaabaa -> ababbbbaababa
bababbbbaaa -> abbbbaababa

# < a,b | bababbbbaabbaa=a >
bababbbbaabbaa -> a

# < a,b | bababbbbaabbba=a >
bababbbbaabbba -> a
bababbbbaabba -> ababbbbaabbba
bababbbbaaba -> ababbbbaabba
bababbbbaaa -> ababbbbaaba

# < a,b | bababbbbabaaaa=a >
bababbbbabaaaa -> a

# < a,b | bababbbbabaaba=a >
bababbbbabaaba -> a
bababbbbabaaa -> ababbbbabaaba

# < a,b | bababbbbababaa=a >
bababbbbababaa -> a

# < a,b | bababbbbabbaaa=a >
bababbbbabbaaa -> a

# < a,b | bababbbbabbbaa=a >
bababbbbabbbaa -> a

# < a,b | bababbbbbaaaaa=a >
bababbbbbaaaaa -> a

# < a,b | bababbbbbaaaba=a >
bababbbbbaaaba -> a
bababbbbbaaaa -> ababbbbbaaaba

# < a,b | bababbbbbaabaa=a >
bababbbbbaabaa -> a

# < a,b | bababbbbbaabba=a >
bababbbbbaabba -> a
bababbbbbaaba -> ababbbbbaabba
bababbbbbaaa -> ababbbbbaaba

# < a,b | bababbbbbabaaa=a >
bababbbbbabaaa -> a

# < a,b | bababbbbbababa=a >
bababbbbbababa -> a
bababbbbbabaa -> ababbbbbababa
bababbbbbaa -> abbbbbababa

# < a,b | bababbbbbabbaa=a >
bababbbbbabbaa -> a

# < a,b | bababbbbbbaaaa=a >
bababbbbbbaaaa -> a

# < a,b | bababbbbbbaaba=a >
bababbbbbbaaba -> a
bababbbbbbaaa -> ababbbbbbaaba

# < a,b | bababbbbbbabaa=a >
bababbbbbbabaa -> a

# < a,b | bababbbbbbbaaa=a >
bababbbbbbbaaa -> a

# < a,b | bababbbbbbbbaa=a >
bababbbbbbbbaa -> a

# < a,b | babbaaaaaaaaaa=a >
babbaaaaaaaaaa -> a

# < a,b | babbaaaaaaaaba=a >
babbaaaaaaaaba -> a
babbaaaaaaaaa -> abbaaaaaaaaba

# < a,b | babbaaaaaaabaa=a >
babbaaaaaaabaa -> a

# < a,b | babbaaaaaaabba=a >
babbaaaaaaabba -> a
babbaaaaaaaba -> abbaaaaaaabba
babbaaaaaaaa -> abbaaaaaaaba

# < a,b | babbaaaaaabaaa=a >
babbaaaaaabaaa -> a

# < a,b | babbaaaaaababa=a >
babbaaaaaababa -> a
babbaaaaaabaa -> abbaaaaaababa

# < a,b | babbaaaaaabbaa=a >
babbaaaaaabbaa -> a

# < a,b | babbaaaaaabbba=a >
babbaaaaaabbba -> a
babbaaaaaabba -> abbaaaaaabbba
babbaaaaaaba -> abbaaaaaabba
babbaaaaaaa -> abbaaaaaaba

# < a,b | babbaaaaabaaaa=a >
babbaaaaabaaaa -> a

# < a,b | babbaaaaabaaba=a >
babbaaaaabaaba -> a
babbaaaaabaaa -> abbaaaaabaaba

# < a,b | babbaaaaababaa=a >
babbaaaaababaa -> a

# < a,b | babbaaaaababba=a >
babbaaaaababba -> a
babbaaaaababa -> abbaaaaababba
babbaaaaaa -> aaaaababba
babbaaaaabaa -> abbaaaaababa

# < a,b | babbaaaaabbaaa=a >
babbaaaaabbaaa -> a

# < a,b | babbaaaaabbaba=a >
babbaaaaabbaba -> a
babbaaaaabbaa -> abbaaaaabbaba

# < a,b | babbaaaaabbbaa=a >
babbaaaaabbbaa -> a

# < a,b | babbaaaaabbbba=a >
babbaaaaabbbba -> a
babbaaaaabbba -> abbaaaaabbbba
babbaaaaabba -> abbaaaaabbba
babbaaaaaba -> abbaaaaabba
babbaaaaaa -> abbaaaaaba

# < a,b | babbaaaabaaaaa=a >
babbaaaabaaaaa -> a

# < a,b | babbaaaabaaaba=a >
babbaaaabaaaba -> a
babbaaaabaaaa -> abbaaaabaaaba

# < a,b | babbaaaabaabaa=a >
babbaaaabaabaa -> a

# < a,b | babbaaaabaabba=a >
babbaaaabaabba -> a
babbaaaabaaba -> abbaaaabaabba
babbaaaabaaa -> abbaaaabaaba

# < a,b | babbaaaababaaa=a >
babbaaaababaaa -> a

# < a,b | babbaaaabababa=a >
babbaaaabababa -> a
babbaaaababaa -> abbaaaabababa

# < a,b | babbaaaababbaa=a >
babbaaaababbaa -> a
babbaaaaa -> aaababbaa

# < a,b | babbaaaabbaaaa=a >
babbaaaabbaaaa -> a

# < a,b | babbaaaabbaaba=a >
babbaaaabbaaba -> a
babbaaaabbaaa -> abbaaaabbaaba

# < a,b | babbaaaabbabaa=a >
babbaaaabbabaa -> a

# < a,b | babbaaaabbabba=a >
babbaaaabbabba -> a
babbaaaabbaba -> abbaaaabbabba
babbaaaaba -> aaaabbabba
babbaaaabbaa -> abbaaaabbaba
babbaaaaa -> aaaabbaba

# < a,b | babbaaaabbbaaa=a >
babbaaaabbbaaa -> a

# < a,b | babbaaaabbbaba=a >
babbaaaabbbaba -> a
babbaaaabbbaa -> abbaaaabbbaba

# < a,b | babbaaaabbbbaa=a >
babbaaaabbbbaa -> a

# < a,b | babbaaaabbbbba=a >
babbaaaabbbbba -> a
babbaaaabbbba -> abbaaaabbbbba
babbaaaabbba -> abbaaaabbbba
babbaaaabba -> abbaaaabbba
babbaaaaba -> abbaaaabba
babbaaaaa -> abbaaaaba

# < a,b | babbaaabaaaaaa=a >
babbaaabaaaaaa -> a

# < a,b | babbaaabaaaaba=a >
babbaaabaaaaba -> a
babbaaabaaaaa -> abbaaabaaaaba

# < a,b | babbaaabaaabaa=a >
babbaaabaaabaa -> a

# < a,b | babbaaabaaabba=a >
babbaaabaaabba -> a
babbaaabaaaba -> abbaaabaaabba
babbaaabaaaa -> abbaaabaaaba

# < a,b | babbaaabaabaaa=a >
babbaaabaabaaa -> a

# < a,b | babbaaabaababa=a >
babbaaabaababa -> a
babbaaabaabaa -> abbaaabaababa

# < a,b | babbaaabaabbaa=a >
babbaaabaabbaa -> a

# < a,b | babbaaabaabbba=a >
babbaaabaabbba -> a
babbaaabaabba -> abbaaabaabbba
babbaaabaaba -> abbaaabaabba
babbaaabaaa -> abbaaabaaba

# < a,b | babbaaababaaaa=a >
babbaaababaaaa -> a

# < a,b | babbaaababaaba=a >
babbaaababaaba -> a
babbaaababaaa -> abbaaababaaba

# < a,b | babbaaabababaa=a >
babbaaabababaa -> a

# < a,b | babbaaabababba=a >
babbaaabababba -> a
babbaaabababa -> abbaaabababba
babbaaabaa -> aaabababba
babbaaababaa -> abbaaabababa

# < a,b | babbaaababbaaa=a >
babbaaababbaaa -> a
babbaaaa -> ababbaaa

# < a,b | babbaaababbbaa=a >
babbaaababbbaa -> a

# < a,b | babbaaabbaaaaa=a >
babbaaabbaaaaa -> a

# < a,b | babbaaabbaaaba=a >
babbaaabbaaaba -> a
babbaaabbaaaa -> abbaaabbaaaba

# < a,b | babbaaabbaabaa=a >
babbaaabbaabaa -> a

# < a,b | babbaaabbaabba=a >
babbaaabbaabba -> a
babbaaabbaaba -> abbaaabbaabba
babbaaabbaaa -> abbaaabbaaba

# < a,b | babbaaabbabaaa=a >
babbaaabbabaaa -> a

# < a,b | babbaaabbababa=a >
babbaaabbababa -> a
babbaaabbabaa -> abbaaabbababa

# < a,b | babbaaabbbaaaa=a >
babbaaabbbaaaa -> a

# < a,b | babbaaabbbaaba=a >
babbaaabbbaaba -> a
babbaaabbbaaa -> abbaaabbbaaba

# < a,b | babbaaabbbabaa=a >
babbaaabbbabaa -> a

# < a,b | babbaaabbbabba=a >
babbaaabbbabba -> a
babbaaabbbaba -> abbaaabbbabba
babbaaabba -> aaabbbabba
babbaaabbbaa -> abbaaabbbaba
babbaaaba -> aaabbbaba
babbaaaa -> aaabbbaa

# < a,b | babbaaabbbbaaa=a >
babbaaabbbbaaa -> a

# < a,b | babbaaabbbbaba=a >
babbaaabbbbaba -> a
babbaaabbbbaa -> abbaaabbbbaba

# < a,b | babbaaabbbbbaa=a >
babbaaabbbbbaa -> a

# < a,b | babbaaabbbbbba=a >
babbaaabbbbbba -> a
babbaaabbbbba -> abbaaabbbbbba
babbaaabbbba -> abbaaabbbbba
babbaaabbba -> abbaaabbbba
babbaaabba -> abbaaabbba
babbaaaba -> abbaaabba
babbaaaa -> abbaaaba

# < a,b | babbaabaaaaaaa=a >
babbaabaaaaaaa -> a

# < a,b | babbaabaaaaaba=a >
babbaabaaaaaba -> a
babbaabaaaaaa -> abbaabaaaaaba

# < a,b | babbaabaaaabaa=a >
babbaabaaaabaa -> a

# < a,b | babbaabaaaabba=a >
babbaabaaaabba -> a
babbaabaaaaba -> abbaabaaaabba
babbaabaaaaa -> abbaabaaaaba

# < a,b | babbaabaaabaaa=a >
babbaabaaabaaa -> a

# < a,b | babbaabaaababa=a >
babbaabaaababa -> a
babbaabaaabaa -> abbaabaaababa

# < a,b | babbaabaaabbaa=a >
babbaabaaabbaa -> a

# < a,b | babbaabaaabbba=a >
babbaabaaabbba -> a
babbaabaaabba -> abbaabaaabbba
babbaabaaaba -> abbaabaaabba
babbaabaaaa -> abbaabaaaba

# < a,b | babbaabaabaaaa=a >
babbaabaabaaaa -> a

# < a,b | babbaabaabaaba=a >
babbaabaabaaba -> a
babbaabaabaaa -> abbaabaabaaba

# < a,b | babbaabaababaa=a >
babbaabaababaa -> a

# < a,b | babbaabaababba=a >
babbaabaababba -> a
babbaabaababa -> abbaabaababba
babbaabaaa -> aabaababba
babbaabaabaa -> abbaabaababa

# < a,b | babbaabaabbaaa=a >
babbaabaabbaaa -> a

# < a,b | babbaabaabbaba=a >
babbaabaabbaba -> a
babbaabaabbaa -> abbaabaabbaba

# < a,b | babbaabaabbbaa=a >
babbaabaabbbaa -> a

# < a,b | babbaabaabbbba=a >
babbaabaabbbba -> a
babbaabaabbba -> abbaabaabbbba
babbaabaabba -> abbaabaabbba
babbaabaaba -> abbaabaabba
babbaabaaa -> abbaabaaba

# < a,b | babbaababaaaaa=a >
babbaababaaaaa -> a

# < a,b | babbaababaaaba=a >
babbaababaaaba -> a
babbaababaaaa -> abbaababaaaba

# < a,b | babbaababaabaa=a >
babbaababaabaa -> a

# < a,b | babbaababaabba=a >
babbaababaabba -> a
babbaababaaba -> abbaababaabba
babbaababaaa -> abbaababaaba

# < a,b | babbaabababaaa=a >
babbaabababaaa -> a

# < a,b | babbaababababa=a >
babbaababababa -> a
babbaabababaa -> abbaababababa

# < a,b | babbaabababbaa=a >
babbaabababbaa -> a
babbaabaa -> abababbaa

# < a,b | babbaababbaaaa=a >
babbaababbaaaa -> a

# < a,b | babbaababbaaba=a >
babbaababbaaba -> a
babbaaa -> abbaaba

# < a,b | babbaababbabaa=a >
babbaababbabaa -> a

# < a,b | babbaababbbaaa=a >
babbaababbbaaa -> a

# < a,b | babbaababbbaba=a >
babbaababbbaba -> a
babbaababbbaa -> abbaababbbaba

# < a,b | babbaababbbbaa=a >
babbaababbbbaa -> a

# < a,b | babbaabbaaaaaa=a >
babbaabbaaaaaa -> a

# < a,b | babbaabbaaaaba=a >
babbaabbaaaaba -> a
babbaabbaaaaa -> abbaabbaaaaba

# < a,b | babbaabbaaabaa=a >
babbaabbaaabaa -> a

# < a,b | babbaabbaaabba=a >
babbaabbaaabba -> a
babbaabbaaaba -> abbaabbaaabba
babbaabbaaaa -> abbaabbaaaba

# < a,b | babbaabbaabaaa=a >
babbaabbaabaaa -> a

# < a,b | babbaabbaababa=a >
babbaabbaababa -> a
babbaabbaabaa -> abbaabbaababa

# < a,b | babbaabbaabbaa=a >
babbaabbaabbaa -> a

# < a,b | babbaabbaabbba=a >
babbaabbaabbba -> a
babbaabbaabba -> abbaabbaabbba
babbaabbaaba -> abbaabbaabba
babbaabbaaa -> abbaabbaaba

# < a,b | babbaabbabaaaa=a >
babbaabbabaaaa -> a

# < a,b | babbaabbabaaba=a >
babbaabbabaaba -> a
babbaabbabaaa -> abbaabbabaaba

# < a,b | babbaabbababaa=a >
babbaabbababaa -> a

# < a,b | babbaabbababba=a >
babbaabbababba -> a
babbaabbababa -> abbaabbababba
babbaabbaa -> aabbababba
babbaabbabaa -> abbaabbababa

# < a,b | babbaabbabbaaa=a >
babbaabbabbaaa -> a

# < a,b | babbaabbabbbaa=a >
babbaabbabbbaa -> a

# < a,b | babbaabbbaaaaa=a >
babbaabbbaaaaa -> a

# < a,b | babbaabbbaaaba=a >
babbaabbbaaaba -> a
babbaabbbaaaa -> abbaabbbaaaba

# < a,b | babbaabbbaabaa=a >
babbaabbbaabaa -> a

# < a,b | babbaabbbaabba=a >
babbaabbbaabba -> a
babbaabbbaaba -> abbaabbbaabba
babbaabbbaaa -> abbaabbbaaba

# < a,b | babbaabbbabaaa=a >
babbaabbbabaaa -> a

# < a,b | babbaabbbababa=a >
babbaabbbababa -> a
babbaabbbabaa -> abbaabbbababa

# < a,b | babbaabbbbaaaa=a >
babbaabbbbaaaa -> a

# < a,b | babbaabbbbaaba=a >
babbaabbbbaaba -> a
babbaabbbbaaa -> abbaabbbbaaba

# < a,b | babbaabbbbabaa=a >
babbaabbbbabaa -> a

# < a,b | babbaabbbbbaaa=a >
babbaabbbbbaaa -> a

# < a,b | babbaabbbbbaba=a >
babbaabbbbbaba -> a
babbaabbbbbaa -> abbaabbbbbaba

# < a,b | babbaabbbbbbaa=a >
babbaabbbbbbaa -> a

# < a,b | babbaabbbbbbba=a >
babbaabbbbbbba -> a
babbaabbbbbba -> abbaabbbbbbba
babbaabbbbba -> abbaabbbbbba
babbaabbbba -> abbaabbbbba
babbaabbba -> abbaabbbba
babbaabba -> abbaabbba
babbaaba -> abbaabba
babbaaa -> abbaaba

# < a,b | babbabaaaaaaaa=a >
babbabaaaaaaaa -> a

# < a,b | babbabaaaaaaba=a >
babbabaaaaaaba -> a
babbabaaaaaaa -> abbabaaaaaaba

# < a,b | babbabaaaaabaa=a >
babbabaaaaabaa -> a

# < a,b | babbabaaaaabba=a >
babbabaaaaabba -> a
babbabaaaaaba -> abbabaaaaabba
babbabaaaaaa -> abbabaaaaaba

# < a,b | babbabaaaabaaa=a >
babbabaaaabaaa -> a

# < a,b | babbabaaaababa=a >
babbabaaaababa -> a
babbabaaaabaa -> abbabaaaababa

# < a,b | babbabaaaabbaa=a >
babbabaaaabbaa -> a

# < a,b | babbabaaaabbba=a >
babbabaaaabbba -> a
babbabaaaabba -> abbabaaaabbba
babbabaaaaba -> abbabaaaabba
babbabaaaaa -> abbabaaaaba

# < a,b | babbabaaabaaaa=a >
babbabaaabaaaa -> a

# < a,b | babbabaaabaaba=a >
babbabaaabaaba -> a
babbabaaabaaa -> abbabaaabaaba

# < a,b | babbabaaababaa=a >
babbabaaababaa -> a

# < a,b | babbabaaababba=a >
babbabaaababba -> a
babbabaaababa -> abbabaaababba
babbabaaaa -> abaaababba
babbabaaabaa -> abbabaaababa

# < a,b | babbabaaabbaaa=a >
babbabaaabbaaa -> a

# < a,b | babbabaaabbaba=a >
babbabaaabbaba -> a
babbabaaabbaa -> abbabaaabbaba

# < a,b | babbabaaabbbaa=a >
babbabaaabbbaa -> a

# < a,b | babbabaaabbbba=a >
babbabaaabbbba -> a
babbabaaabbba -> abbabaaabbbba
babbabaaabba -> abbabaaabbba
babbabaaaba -> abbabaaabba
babbabaaaa -> abbabaaaba

# < a,b | babbabaabaaaaa=a >
babbabaabaaaaa -> a

# < a,b | babbabaabaaaba=a >
babbabaabaaaba -> a
babbabaabaaaa -> abbabaabaaaba

# < a,b | babbabaabaabaa=a >
babbabaabaabaa -> a

# < a,b | babbabaabaabba=a >
babbabaabaabba -> a
babbabaabaaba -> abbabaabaabba
babbabaabaaa -> abbabaabaaba

# < a,b | babbabaababaaa=a >
babbabaababaaa -> a

# < a,b | babbabaabababa=a >
babbabaabababa -> a
babbabaababaa -> abbabaabababa

# < a,b | babbabaababbaa=a >
babbabaababbaa -> a

# < a,b | babbabaabbaaaa=a >
babbabaabbaaaa -> a

# < a,b | babbabaabbaaba=a >
babbabaabbaaba -> a
babbabaabbaaa -> abbabaabbaaba

# < a,b | babbabaabbabaa=a >
babbabaabbabaa -> a

# < a,b | babbabaabbabba=a >
babbabaabbabba -> a
babbabaabbaba -> abbabaabbabba
babbabaaba -> abaabbabba
babbabaabbaa -> abbabaabbaba
babbabaaa -> abaabbaba

# < a,b | babbabaabbbaaa=a >
babbabaabbbaaa -> a

# < a,b | babbabaabbbaba=a >
babbabaabbbaba -> a
babbabaabbbaa -> abbabaabbbaba

# < a,b | babbabaabbbbaa=a >
babbabaabbbbaa -> a

# < a,b | babbabaabbbbba=a >
babbabaabbbbba -> a
babbabaabbbba -> abbabaabbbbba
babbabaabbba -> abbabaabbbba
babbabaabba -> abbabaabbba
babbabaaba -> abbabaabba
babbabaaa -> abbabaaba

# < a,b | babbababaaaaaa=a >
babbababaaaaaa -> a

# < a,b | babbababaaaaba=a >
babbababaaaaba -> a
babbababaaaaa -> abbababaaaaba

# < a,b | babbababaaabaa=a >
babbababaaabaa -> a

# < a,b | babbababaaabba=a >
babbababaaabba -> a
babbababaaaba -> abbababaaabba
babbababaaaa -> abbababaaaba

# < a,b | babbababaabaaa=a >
babbababaabaaa -> a

# < a,b | babbababaababa=a >
babbababaababa -> a
babbababaabaa -> abbababaababa

# < a,b | babbababaabbaa=a >
babbababaabbaa -> a

# < a,b | babbababaabbba=a >
babbababaabbba -> a
babbababaabba -> abbababaabbba
babbababaaba -> abbababaabba
babbababaaa -> abbababaaba

# < a,b | babbabababaaaa=a >
babbabababaaaa -> a

# < a,b | babbabababaaba=a >
babbabababaaba -> a
babbabababaaa -> abbabababaaba

# < a,b | babbababababaa=a >
babbababababaa -> a

# < a,b | babbababababba=a >
babbababababba -> a
babbababababa -> abbababababba
babbababaa -> ababababba
babbabababaa -> abbababababa

# < a,b | babbabababbaaa=a >
babbabababbaaa -> a

# < a,b | babbabababbaba=a >
babbabababbaba -> a
babbabababbaa -> abbabababbaba
babbabaa -> ababbaba

# < a,b | babbabababbbaa=a >
babbabababbbaa -> a

# < a,b | babbababbaaaaa=a >
babbababbaaaaa -> a

# < a,b | babbababbaaaba=a >
babbababbaaaba -> a
babbababbaaaa -> abbababbaaaba

# < a,b | babbababbaabaa=a >
babbababbaabaa -> a

# < a,b | babbababbaabba=a >
babbababbaabba -> a
babbababbaaba -> abbababbaabba
babbababbaaa -> abbababbaaba

# < a,b | babbababbabaaa=a >
babbababbabaaa -> a

# < a,b | babbababbababa=a >
babbababbababa -> a
babbababbabaa -> abbababbababa

# < a,b | babbababbabbaa=a >
babbababbabbaa -> a

# < a,b | babbababbbaaaa=a >
babbababbbaaaa -> a

# < a,b | babbababbbaaba=a >
babbababbbaaba -> a
babbababbbaaa -> abbababbbaaba

# < a,b | babbababbbabaa=a >
babbababbbabaa -> a

# < a,b | babbababbbabba=a >
babbababbbabba -> a
babbababbbaba -> abbababbbabba
babbababba -> ababbbabba
babbababbbaa -> abbababbbaba
babbababa -> ababbbaba
babbaa -> ababba
babbabaa -> ababbbaa

# < a,b | babbababbbbaaa=a >
babbababbbbaaa -> a

# < a,b | babbababbbbaba=a >
babbababbbbaba -> a
babbababbbbaa -> abbababbbbaba

# < a,b | babbababbbbbaa=a >
babbababbbbbaa -> a

# < a,b | babbabbaaaaaaa=a >
babbabbaaaaaaa -> a

# < a,b | babbabbaaaaaba=a >
babbabbaaaaaba -> a
babbabbaaaaaa -> abbabbaaaaaba

# < a,b | babbabbaaaabaa=a >
babbabbaaaabaa -> a

# < a,b | babbabbaaaabba=a >
babbabbaaaabba -> a
babbabbaaaaba -> abbabbaaaabba
babbabbaaaaa -> abbabbaaaaba

# < a,b | babbabbaaabaaa=a >
babbabbaaabaaa -> a

# < a,b | babbabbaaababa=a >
babbabbaaababa -> a
babbabbaaabaa -> abbabbaaababa

# < a,b | babbabbaaabbaa=a >
babbabbaaabbaa -> a

# < a,b | babbabbaaabbba=a >
babbabbaaabbba -> a
babbabbaaabba -> abbabbaaabbba
babbabbaaaba -> abbabbaaabba
babbabbaaaa -> abbabbaaaba

# < a,b | babbabbaabaaaa=a >
babbabbaabaaaa -> a

# < a,b | babbabbaabaaba=a >
babbabbaabaaba -> a
babbabbaabaaa -> abbabbaabaaba

# < a,b | babbabbaababaa=a >
babbabbaababaa -> a

# < a,b | babbabbaababba=a >
babbabbaababba -> a
babbabbaababa -> abbabbaababba
babbabbaaa -> abbaababba
babbabbaabaa -> abbabbaababa

# < a,b | babbabbaabbaaa=a >
babbabbaabbaaa -> a

# < a,b | babbabbaabbaba=a >
babbabbaabbaba -> a
babbabbaabbaa -> abbabbaabbaba

# < a,b | babbabbaabbbaa=a >
babbabbaabbbaa -> a

# < a,b | babbabbaabbbba=a >
babbabbaabbbba -> a
babbabbaabbba -> abbabbaabbbba
babbabbaabba -> abbabbaabbba
babbabbaaba -> abbabbaabba
babbabbaaa -> abbabbaaba

# < a,b | babbabbabaaaaa=a >
babbabbabaaaaa -> a

# < a,b | babbabbabaaaba=a >
babbabbabaaaba -> a
babbabbabaaaa -> abbabbabaaaba

# < a,b | babbabbabaabaa=a >
babbabbabaabaa -> a

# < a,b | babbabbabaabba=a >
babbabbabaabba -> a
babbabbabaaba -> abbabbabaabba
babbabbabaaa -> abbabbabaaba

# < a,b | babbabbababaaa=a >
babbabbababaaa -> a

# < a,b | babbabbabababa=a >
babbabbabababa -> a
babbabbababaa -> abbabbabababa

# < a,b | babbabbababbaa=a >
babbabbababbaa -> a

# < a,b | babbabbabbaaaa=a >
babbabbabbaaaa -> a

# < a,b | babbabbabbaaba=a >
babbabbabbaaba -> a
babbabbabbaaa -> abbabbabbaaba

# < a,b | babbabbabbabaa=a >
babbabbabbabaa -> a

# < a,b | babbabbabbabba=a >
babbabbabbabba -> a
baba -> abba
baa -> aba

# < a,b | babbabbabbbaaa=a >
babbabbabbbaaa -> a

# < a,b | babbabbabbbaba=a >
babbabbabbbaba -> a
babbabbabbbaa -> abbabbabbbaba

# < a,b | babbabbabbbbaa=a >
babbabbabbbbaa -> a

# < a,b | babbabbbaaaaaa=a >
babbabbbaaaaaa -> a

# < a,b | babbabbbaaaaba=a >
babbabbbaaaaba -> a
babbabbbaaaaa -> abbabbbaaaaba

# < a,b | babbabbbaaabaa=a >
babbabbbaaabaa -> a

# < a,b | babbabbbaaabba=a >
babbabbbaaabba -> a
babbabbbaaaba -> abbabbbaaabba
babbabbbaaaa -> abbabbbaaaba

# < a,b | babbabbbaabaaa=a >
babbabbbaabaaa -> a

# < a,b | babbabbbaababa=a >
babbabbbaababa -> a
babbabbbaabaa -> abbabbbaababa

# < a,b | babbabbbaabbaa=a >
babbabbbaabbaa -> a

# < a,b | babbabbbaabbba=a >
babbabbbaabbba -> a
babbabbbaabba -> abbabbbaabbba
babbabbbaaba -> abbabbbaabba
babbabbbaaa -> abbabbbaaba

# < a,b | babbabbbabaaaa=a >
babbabbbabaaaa -> a

# < a,b | babbabbbabaaba=a >
babbabbbabaaba -> a
babbabbbabaaa -> abbabbbabaaba

# < a,b | babbabbbababaa=a >
babbabbbababaa -> a

# < a,b | babbabbbababba=a >
babbabbbababba -> a
babbabbbababa -> abbabbbababba
babbabbbaa -> abbbababba
babbabbbabaa -> abbabbbababa

# < a,b | babbabbbabbaaa=a >
babbabbbabbaaa -> a

# < a,b | babbabbbabbaba=a >
babbabbbabbaba -> a
babbabbbabbaa -> abbabbbabbaba

# < a,b | babbabbbabbbaa=a >
babbabbbabbbaa -> a

# < a,b | babbabbbbaaaaa=a >
babbabbbbaaaaa -> a

# < a,b | babbabbbbaaaba=a >
babbabbbbaaaba -> a
babbabbbbaaaa -> abbabbbbaaaba

# < a,b | babbabbbbaabaa=a >
babbabbbbaabaa -> a

# < a,b | babbabbbbaabba=a >
babbabbbbaabba -> a
babbabbbbaaba -> abbabbbbaabba
babbabbbbaaa -> abbabbbbaaba

# < a,b | babbabbbbabaaa=a >
babbabbbbabaaa -> a

# < a,b | babbabbbbababa=a >
babbabbbbababa -> a
babbabbbbabaa -> abbabbbbababa

# < a,b | babbabbbbabbaa=a >
babbabbbbabbaa -> a

# < a,b | babbabbbbbaaaa=a >
babbabbbbbaaaa -> a

# < a,b | babbabbbbbaaba=a >
babbabbbbbaaba -> a
babbabbbbbaaa -> abbabbbbbaaba

# < a,b | babbabbbbbabaa=a >
babbabbbbbabaa -> a

# < a,b | babbabbbbbbaaa=a >
babbabbbbbbaaa -> a

# < a,b | babbabbbbbbaba=a >
babbabbbbbbaba -> a
babbabbbbbbaa -> abbabbbbbbaba

# < a,b | babbabbbbbbbaa=a >
babbabbbbbbbaa -> a

# < a,b | babbbaaaaaaaaa=a >
babbbaaaaaaaaa -> a

# < a,b | babbbaaaaaaaba=a >
babbbaaaaaaaba -> a
babbbaaaaaaaa -> abbbaaaaaaaba

# < a,b | babbbaaaaaabaa=a >
babbbaaaaaabaa -> a

# < a,b | babbbaaaaaabba=a >
babbbaaaaaabba -> a
babbbaaaaaaba -> abbbaaaaaabba
babbbaaaaaaa -> abbbaaaaaaba

# < a,b | babbbaaaaabaaa=a >
babbbaaaaabaaa -> a

# < a,b | babbbaaaaababa=a >
babbbaaaaababa -> a
babbbaaaaabaa -> abbbaaaaababa

# < a,b | babbbaaaaabbaa=a >
babbbaaaaabbaa -> a

# < a,b | babbbaaaaabbba=a >
babbbaaaaabbba -> a
babbbaaaaabba -> abbbaaaaabbba
babbbaaaaaba -> abbbaaaaabba
babbbaaaaaa -> abbbaaaaaba

# < a,b | babbbaaaabaaaa=a >
babbbaaaabaaaa -> a

# < a,b | babbbaaaabaaba=a >
babbbaaaabaaba -> a
babbbaaaabaaa -> abbbaaaabaaba

# < a,b | babbbaaaababaa=a >
babbbaaaababaa -> a

# < a,b | babbbaaaababba=a >
babbbaaaababba -> a
babbbaaaababa -> abbbaaaababba
babbbaaaabaa -> abbbaaaababa

# < a,b | babbbaaaabbaaa=a >
babbbaaaabbaaa -> a

# < a,b | babbbaaaabbaba=a >
babbbaaaabbaba -> a
babbbaaaabbaa -> abbbaaaabbaba

# < a,b | babbbaaaabbbaa=a >
babbbaaaabbbaa -> a

# < a,b | babbbaaaabbbba=a >
babbbaaaabbbba -> a
babbbaaaabbba -> abbbaaaabbbba
babbbaaaabba -> abbbaaaabbba
babbbaaaaba -> abbbaaaabba
babbbaaaaa -> abbbaaaaba

# < a,b | babbbaaabaaaaa=a >
babbbaaabaaaaa -> a

# < a,b | babbbaaabaaaba=a >
babbbaaabaaaba -> a
babbbaaabaaaa -> abbbaaabaaaba

# < a,b | babbbaaabaabaa=a >
babbbaaabaabaa -> a

# < a,b | babbbaaabaabba=a >
babbbaaabaabba -> a
babbbaaabaaba -> abbbaaabaabba
babbbaaabaaa -> abbbaaabaaba

# < a,b | babbbaaababaaa=a >
babbbaaababaaa -> a

# < a,b | babbbaaabababa=a >
babbbaaabababa -> a
babbbaaababaa -> abbbaaabababa

# < a,b | babbbaaababbaa=a >
babbbaaababbaa -> a

# < a,b | babbbaaababbba=a >
babbbaaababbba -> a
babbbaaababba -> abbbaaababbba
babbbaaaa -> aaababbba
babbbaaababa -> abbbaaababba
babbbaaabaa -> abbbaaababa

# < a,b | babbbaaabbaaaa=a >
babbbaaabbaaaa -> a

# < a,b | babbbaaabbaaba=a >
babbbaaabbaaba -> a
babbbaaabbaaa -> abbbaaabbaaba

# < a,b | babbbaaabbabaa=a >
babbbaaabbabaa -> a

# < a,b | babbbaaabbabba=a >
babbbaaabbabba -> a
babbbaaabbaba -> abbbaaabbabba
babbbaaabbaa -> abbbaaabbaba

# < a,b | babbbaaabbbaaa=a >
babbbaaabbbaaa -> a

# < a,b | babbbaaabbbaba=a >
babbbaaabbbaba -> a
babbbaaabbbaa -> abbbaaabbbaba

# < a,b | babbbaaabbbbaa=a >
babbbaaabbbbaa -> a

# < a,b | babbbaaabbbbba=a >
babbbaaabbbbba -> a
babbbaaabbbba -> abbbaaabbbbba
babbbaaabbba -> abbbaaabbbba
babbbaaabba -> abbbaaabbba
babbbaaaba -> abbbaaabba
babbbaaaa -> abbbaaaba

# < a,b | babbbaabaaaaaa=a >
babbbaabaaaaaa -> a

# < a,b | babbbaabaaaaba=a >
babbbaabaaaaba -> a
babbbaabaaaaa -> abbbaabaaaaba

# < a,b | babbbaabaaabaa=a >
babbbaabaaabaa -> a

# < a,b | babbbaabaaabba=a >
babbbaabaaabba -> a
babbbaabaaaba -> abbbaabaaabba
babbbaabaaaa -> abbbaabaaaba

# < a,b | babbbaabaabaaa=a >
babbbaabaabaaa -> a

# < a,b | babbbaabaababa=a >
babbbaabaababa -> a
babbbaabaabaa -> abbbaabaababa

# < a,b | babbbaabaabbaa=a >
babbbaabaabbaa -> a

# < a,b | babbbaabaabbba=a >
babbbaabaabbba -> a
babbbaabaabba -> abbbaabaabbba
babbbaabaaba -> abbbaabaabba
babbbaabaaa -> abbbaabaaba

# < a,b | babbbaababaaaa=a >
babbbaababaaaa -> a

# < a,b | babbbaababaaba=a >
babbbaababaaba -> a
babbbaababaaa -> abbbaababaaba

# < a,b | babbbaabababaa=a >
babbbaabababaa -> a

# < a,b | babbbaabababba=a >
babbbaabababba -> a
babbbaabababa -> abbbaabababba
babbbaababaa -> abbbaabababa

# < a,b | babbbaababbaaa=a >
babbbaababbaaa -> a

# < a,b | babbbaababbaba=a >
babbbaababbaba -> a
babbbaababbaa -> abbbaababbaba

# < a,b | babbbaababbbaa=a >
babbbaababbbaa -> a
babbbaaa -> ababbbaa

# < a,b | babbbaabbaaaaa=a >
babbbaabbaaaaa -> a

# < a,b | babbbaabbaaaba=a >
babbbaabbaaaba -> a
babbbaabbaaaa -> abbbaabbaaaba

# < a,b | babbbaabbaabaa=a >
babbbaabbaabaa -> a

# < a,b | babbbaabbaabba=a >
babbbaabbaabba -> a
babbbaabbaaba -> abbbaabbaabba
babbbaabbaaa -> abbbaabbaaba

# < a,b | babbbaabbabaaa=a >
babbbaabbabaaa -> a

# < a,b | babbbaabbababa=a >
babbbaabbababa -> a
babbbaabbabaa -> abbbaabbababa

# < a,b | babbbaabbabbaa=a >
babbbaabbabbaa -> a

# < a,b | babbbaabbabbba=a >
babbbaabbabbba -> a
babbbaabbabba -> abbbaabbabbba
babbbaaba -> aabbabbba
babbbaabbaba -> abbbaabbabba
babbbaaa -> aabbabba
babbbaabbaa -> abbbaabbaba

# < a,b | babbbaabbbaaaa=a >
babbbaabbbaaaa -> a

# < a,b | babbbaabbbaaba=a >
babbbaabbbaaba -> a
babbbaabbbaaa -> abbbaabbbaaba

# < a,b | babbbaabbbabaa=a >
babbbaabbbabaa -> a

# < a,b | babbbaabbbabba=a >
babbbaabbbabba -> a
babbbaabbbaba -> abbbaabbbabba
babbbaabbbaa -> abbbaabbbaba

# < a,b | babbbaabbbbaaa=a >
babbbaabbbbaaa -> a

# < a,b | babbbaabbbbaba=a >
babbbaabbbbaba -> a
babbbaabbbbaa -> abbbaabbbbaba

# < a,b | babbbaabbbbbaa=a >
babbbaabbbbbaa -> a

# < a,b | babbbaabbbbbba=a >
babbbaabbbbbba -> a
babbbaabbbbba -> abbbaabbbbbba
babbbaabbbba -> abbbaabbbbba
babbbaabbba -> abbbaabbbba
babbbaabba -> abbbaabbba
babbbaaba -> abbbaabba
babbbaaa -> abbbaaba

# < a,b | babbbabaaaaaaa=a >
babbbabaaaaaaa -> a

# < a,b | babbbabaaaaaba=a >
babbbabaaaaaba -> a
babbbabaaaaaa -> abbbabaaaaaba

# < a,b | babbbabaaaabaa=a >
babbbabaaaabaa -> a

# < a,b | babbbabaaaabba=a >
babbbabaaaabba -> a
babbbabaaaaba -> abbbabaaaabba
babbbabaaaaa -> abbbabaaaaba

# < a,b | babbbabaaabaaa=a >
babbbabaaabaaa -> a

# < a,b | babbbabaaababa=a >
babbbabaaababa -> a
babbbabaaabaa -> abbbabaaababa

# < a,b | babbbabaaabbaa=a >
babbbabaaabbaa -> a

# < a,b | babbbabaaabbba=a >
babbbabaaabbba -> a
babbbabaaabba -> abbbabaaabbba
babbbabaaaba -> abbbabaaabba
babbbabaaaa -> abbbabaaaba

# < a,b | babbbabaabaaaa=a >
babbbabaabaaaa -> a

# < a,b | babbbabaabaaba=a >
babbbabaabaaba -> a
babbbabaabaaa -> abbbabaabaaba

# < a,b | babbbabaababaa=a >
babbbabaababaa -> a

# < a,b | babbbabaababba=a >
babbbabaababba -> a
babbbabaababa -> abbbabaababba
babbbabaabaa -> abbbabaababa

# < a,b | babbbabaabbaaa=a >
babbbabaabbaaa -> a

# < a,b | babbbabaabbaba=a >
babbbabaabbaba -> a
babbbabaabbaa -> abbbabaabbaba

# < a,b | babbbabaabbbaa=a >
babbbabaabbbaa -> a

# < a,b | babbbabaabbbba=a >
babbbabaabbbba -> a
babbbabaabbba -> abbbabaabbbba
babbbabaabba -> abbbabaabbba
babbbabaaba -> abbbabaabba
babbbabaaa -> abbbabaaba

# < a,b | babbbababaaaaa=a >
babbbababaaaaa -> a

# < a,b | babbbababaaaba=a >
babbbababaaaba -> a
babbbababaaaa -> abbbababaaaba

# < a,b | babbbababaabaa=a >
babbbababaabaa -> a

# < a,b | babbbababaabba=a >
babbbababaabba -> a
babbbababaaba -> abbbababaabba
babbbababaaa -> abbbababaaba

# < a,b | babbbabababaaa=a >
babbbabababaaa -> a

# < a,b | babbbababababa=a >
babbbababababa -> a
babbbabababaa -> abbbababababa

# < a,b | babbbabababbaa=a >
babbbabababbaa -> a

# < a,b | babbbabababbba=a >
babbbabababbba -> a
babbbabababba -> abbbabababbba
babbbabaa -> abababbba
babbbabababa -> abbbabababba
babbbababaa -> abbbabababa

# < a,b | babbbababbaaaa=a >
babbbababbaaaa -> a

# < a,b | babbbababbaaba=a >
babbbababbaaba -> a
babbbababbaaa -> abbbababbaaba

# < a,b | babbbababbabaa=a >
babbbababbabaa -> a

# < a,b | babbbababbabba=a >
babbbababbabba -> a
babbbababbaba -> abbbababbabba
babbbababbaa -> abbbababbaba

# < a,b | babbbababbbaaa=a >
babbbababbbaaa -> a

# < a,b | babbbababbbaba=a >
babbbababbbaba -> a
babbbaa -> abbbaba

# < a,b | babbbababbbbaa=a >
babbbababbbbaa -> a

# < a,b | babbbabbaaaaaa=a >
babbbabbaaaaaa -> a

# < a,b | babbbabbaaaaba=a >
babbbabbaaaaba -> a
babbbabbaaaaa -> abbbabbaaaaba

# < a,b | babbbabbaaabaa=a >
babbbabbaaabaa -> a

# < a,b | babbbabbaaabba=a >
babbbabbaaabba -> a
babbbabbaaaba -> abbbabbaaabba
babbbabbaaaa -> abbbabbaaaba

# < a,b | babbbabbaabaaa=a >
babbbabbaabaaa -> a

# < a,b | babbbabbaababa=a >
babbbabbaababa -> a
babbbabbaabaa -> abbbabbaababa

# < a,b | babbbabbaabbaa=a >
babbbabbaabbaa -> a

# < a,b | babbbabbaabbba=a >
babbbabbaabbba -> a
babbbabbaabba -> abbbabbaabbba
babbbabbaaba -> abbbabbaabba
babbbabbaaa -> abbbabbaaba

# < a,b | babbbabbabaaaa=a >
babbbabbabaaaa -> a

# < a,b | babbbabbabaaba=a >
babbbabbabaaba -> a
babbbabbabaaa -> abbbabbabaaba

# < a,b | babbbabbababaa=a >
babbbabbababaa -> a

# < a,b | babbbabbababba=a >
babbbabbababba -> a
babbbabbababa -> abbbabbababba
babbbabbabaa -> abbbabbababa

# < a,b | babbbabbabbaaa=a >
babbbabbabbaaa -> a

# < a,b | babbbabbabbaba=a >
babbbabbabbaba -> a
babbbabbabbaa -> abbbabbabbaba

# < a,b | babbbabbabbbaa=a >
babbbabbabbbaa -> a

# < a,b | babbbabbbaaaaa=a >
babbbabbbaaaaa -> a

# < a,b | babbbabbbaaaba=a >
babbbabbbaaaba -> a
babbbabbbaaaa -> abbbabbbaaaba

# < a,b | babbbabbbaabaa=a >
babbbabbbaabaa -> a

# < a,b | babbbabbbaabba=a >
babbbabbbaabba -> a
babbbabbbaaba -> abbbabbbaabba
babbbabbbaaa -> abbbabbbaaba

# < a,b | babbbabbbabaaa=a >
babbbabbbabaaa -> a

# < a,b | babbbabbbababa=a >
babbbabbbababa -> a
babbbabbbabaa -> abbbabbbababa

# < a,b | babbbabbbabbaa=a >
babbbabbbabbaa -> a

# < a,b | babbbabbbabbba=a >
babbbabbbabbba -> a
babba -> abbba
baba -> abba
baa -> aba

# < a,b | babbbabbbbaaaa=a >
babbbabbbbaaaa -> a

# < a,b | babbbabbbbaaba=a >
babbbabbbbaaba -> a
babbbabbbbaaa -> abbbabbbbaaba

# < a,b | babbbabbbbabaa=a >
babbbabbbbabaa -> a

# < a,b | babbbabbbbabba=a >
babbbabbbbabba -> a
babbbabbbbaba -> abbbabbbbabba
babbbabbbbaa -> abbbabbbbaba

# < a,b | babbbabbbbbaaa=a >
babbbabbbbbaaa -> a

# < a,b | babbbabbbbbaba=a >
babbbabbbbbaba -> a
babbbabbbbbaa -> abbbabbbbbaba

# < a,b | babbbabbbbbbaa=a >
babbbabbbbbbaa -> a

# < a,b | babbbbaaaaaaaa=a >
babbbbaaaaaaaa -> a

# < a,b | babbbbaaaaaaba=a >
babbbbaaaaaaba -> a
babbbbaaaaaaa -> abbbbaaaaaaba

# < a,b | babbbbaaaaabaa=a >
babbbbaaaaabaa -> a

# < a,b | babbbbaaaaabba=a >
babbbbaaaaabba -> a
babbbbaaaaaba -> abbbbaaaaabba
babbbbaaaaaa -> abbbbaaaaaba

# < a,b | babbbbaaaabaaa=a >
babbbbaaaabaaa -> a

# < a,b | babbbbaaaababa=a >
babbbbaaaababa -> a
babbbbaaaabaa -> abbbbaaaababa

# < a,b | babbbbaaaabbaa=a >
babbbbaaaabbaa -> a

# < a,b | babbbbaaaabbba=a >
babbbbaaaabbba -> a
babbbbaaaabba -> abbbbaaaabbba
babbbbaaaaba -> abbbbaaaabba
babbbbaaaaa -> abbbbaaaaba

# < a,b | babbbbaaabaaaa=a >
babbbbaaabaaaa -> a

# < a,b | babbbbaaabaaba=a >
babbbbaaabaaba -> a
babbbbaaabaaa -> abbbbaaabaaba

# < a,b | babbbbaaababaa=a >
babbbbaaababaa -> a

# < a,b | babbbbaaababba=a >
babbbbaaababba -> a
babbbbaaababa -> abbbbaaababba
babbbbaaabaa -> abbbbaaababa

# < a,b | babbbbaaabbaaa=a >
babbbbaaabbaaa -> a

# < a,b | babbbbaaabbaba=a >
babbbbaaabbaba -> a
babbbbaaabbaa -> abbbbaaabbaba

# < a,b | babbbbaaabbbaa=a >
babbbbaaabbbaa -> a

# < a,b | babbbbaaabbbba=a >
babbbbaaabbbba -> a
babbbbaaabbba -> abbbbaaabbbba
babbbbaaabba -> abbbbaaabbba
babbbbaaaba -> abbbbaaabba
babbbbaaaa -> abbbbaaaba

# < a,b | babbbbaabaaaaa=a >
babbbbaabaaaaa -> a

# < a,b | babbbbaabaaaba=a >
babbbbaabaaaba -> a
babbbbaabaaaa -> abbbbaabaaaba

# < a,b | babbbbaabaabaa=a >
babbbbaabaabaa -> a

# < a,b | babbbbaabaabba=a >
babbbbaabaabba -> a
babbbbaabaaba -> abbbbaabaabba
babbbbaabaaa -> abbbbaabaaba

# < a,b | babbbbaababaaa=a >
babbbbaababaaa -> a

# < a,b | babbbbaabababa=a >
babbbbaabababa -> a
babbbbaababaa -> abbbbaabababa

# < a,b | babbbbaababbaa=a >
babbbbaababbaa -> a

# < a,b | babbbbaababbba=a >
babbbbaababbba -> a
babbbbaababba -> abbbbaababbba
babbbbaababa -> abbbbaababba
babbbbaabaa -> abbbbaababa

# < a,b | babbbbaabbaaaa=a >
babbbbaabbaaaa -> a

# < a,b | babbbbaabbaaba=a >
babbbbaabbaaba -> a
babbbbaabbaaa -> abbbbaabbaaba

# < a,b | babbbbaabbabaa=a >
babbbbaabbabaa -> a

# < a,b | babbbbaabbabba=a >
babbbbaabbabba -> a
babbbbaabbaba -> abbbbaabbabba
babbbbaabbaa -> abbbbaabbaba

# < a,b | babbbbaabbbaaa=a >
babbbbaabbbaaa -> a

# < a,b | babbbbaabbbaba=a >
babbbbaabbbaba -> a
babbbbaabbbaa -> abbbbaabbbaba

# < a,b | babbbbaabbbbaa=a >
babbbbaabbbbaa -> a

# < a,b | babbbbaabbbbba=a >
babbbbaabbbbba -> a
babbbbaabbbba -> abbbbaabbbbba
babbbbaabbba -> abbbbaabbbba
babbbbaabba -> abbbbaabbba
babbbbaaba -> abbbbaabba
babbbbaaa -> abbbbaaba

# < a,b | babbbbabaaaaaa=a >
babbbbabaaaaaa -> a

# < a,b | babbbbabaaaaba=a >
babbbbabaaaaba -> a
babbbbabaaaaa -> abbbbabaaaaba

# < a,b | babbbbabaaabaa=a >
babbbbabaaabaa -> a

# < a,b | babbbbabaaabba=a >
babbbbabaaabba -> a
babbbbabaaaba -> abbbbabaaabba
babbbbabaaaa -> abbbbabaaaba

# < a,b | babbbbabaabaaa=a >
babbbbabaabaaa -> a

# < a,b | babbbbabaababa=a >
babbbbabaababa -> a
babbbbabaabaa -> abbbbabaababa

# < a,b | babbbbabaabbaa=a >
babbbbabaabbaa -> a

# < a,b | babbbbabaabbba=a >
babbbbabaabbba -> a
babbbbabaabba -> abbbbabaabbba
babbbbabaaba -> abbbbabaabba
babbbbabaaa -> abbbbabaaba

# < a,b | babbbbababaaaa=a >
babbbbababaaaa -> a

# < a,b | babbbbababaaba=a >
babbbbababaaba -> a
babbbbababaaa -> abbbbababaaba

# < a,b | babbbbabababaa=a >
babbbbabababaa -> a

# < a,b | babbbbabababba=a >
babbbbabababba -> a
babbbbabababa -> abbbbabababba
babbbbababaa -> abbbbabababa

# < a,b | babbbbababbaaa=a >
babbbbababbaaa -> a

# < a,b | babbbbababbaba=a >
babbbbababbaba -> a
babbbbababbaa -> abbbbababbaba

# < a,b | babbbbababbbaa=a >
babbbbababbbaa -> a

# < a,b | babbbbababbbba=a >
babbbbababbbba -> a
babbbbababbba -> abbbbababbbba
babbbbaa -> ababbbba
babbbbababba -> abbbbababbba
babbbbababa -> abbbbababba
babbbbabaa -> abbbbababa

# < a,b | babbbbabbaaaaa=a >
babbbbabbaaaaa -> a

# < a,b | babbbbabbaaaba=a >
babbbbabbaaaba -> a
babbbbabbaaaa -> abbbbabbaaaba

# < a,b | babbbbabbaabaa=a >
babbbbabbaabaa -> a

# < a,b | babbbbabbaabba=a >
babbbbabbaabba -> a
babbbbabbaaba -> abbbbabbaabba
babbbbabbaaa -> abbbbabbaaba

# < a,b | babbbbabbabaaa=a >
babbbbabbabaaa -> a

# < a,b | babbbbabbababa=a >
babbbbabbababa -> a
babbbbabbabaa -> abbbbabbababa

# < a,b | babbbbabbabbaa=a >
babbbbabbabbaa -> a

# < a,b | babbbbabbabbba=a >
babbbbabbabbba -> a
babbbbabbabba -> abbbbabbabbba
babbbbabbaba -> abbbbabbabba
babbbbabbaa -> abbbbabbaba

# < a,b | babbbbabbbaaaa=a >
babbbbabbbaaaa -> a

# < a,b | babbbbabbbaaba=a >
babbbbabbbaaba -> a
babbbbabbbaaa -> abbbbabbbaaba

# < a,b | babbbbabbbabaa=a >
babbbbabbbabaa -> a

# < a,b | babbbbabbbabba=a >
babbbbabbbabba -> a
babbbbabbbaba -> abbbbabbbabba
babbbbabbbaa -> abbbbabbbaba

# < a,b | babbbbabbbbaaa=a >
babbbbabbbbaaa -> a

# < a,b | babbbbabbbbaba=a >
babbbbabbbbaba -> a
babbbbabbbbaa -> abbbbabbbbaba

# < a,b | babbbbabbbbbaa=a >
babbbbabbbbbaa -> a

# < a,b | babbbbbaaaaaaa=a >
babbbbbaaaaaaa -> a

# < a,b | babbbbbaaaaaba=a >
babbbbbaaaaaba -> a
babbbbbaaaaaa -> abbbbbaaaaaba

# < a,b | babbbbbaaaabaa=a >
babbbbbaaaabaa -> a

# < a,b | babbbbbaaaabba=a >
babbbbbaaaabba -> a
babbbbbaaaaba -> abbbbbaaaabba
babbbbbaaaaa -> abbbbbaaaaba

# < a,b | babbbbbaaabaaa=a >
babbbbbaaabaaa -> a

# < a,b | babbbbbaaababa=a >
babbbbbaaababa -> a
babbbbbaaabaa -> abbbbbaaababa

# < a,b | babbbbbaaabbaa=a >
babbbbbaaabbaa -> a

# < a,b | babbbbbaaabbba=a >
babbbbbaaabbba -> a
babbbbbaaabba -> abbbbbaaabbba
babbbbbaaaba -> abbbbbaaabba
babbbbbaaaa -> abbbbbaaaba

# < a,b | babbbbbaabaaaa=a >
babbbbbaabaaaa -> a

# < a,b | babbbbbaabaaba=a >
babbbbbaabaaba -> a
babbbbbaabaaa -> abbbbbaabaaba

# < a,b | babbbbbaababaa=a >
babbbbbaababaa -> a

# < a,b | babbbbbaababba=a >
babbbbbaababba -> a
babbbbbaababa -> abbbbbaababba
babbbbbaabaa -> abbbbbaababa

# < a,b | babbbbbaabbaaa=a >
babbbbbaabbaaa -> a

# < a,b | babbbbbaabbaba=a >
babbbbbaabbaba -> a
babbbbbaabbaa -> abbbbbaabbaba

# < a,b | babbbbbaabbbaa=a >
babbbbbaabbbaa -> a

# < a,b | babbbbbaabbbba=a >
babbbbbaabbbba -> a
babbbbbaabbba -> abbbbbaabbbba
babbbbbaabba -> abbbbbaabbba
babbbbbaaba -> abbbbbaabba
babbbbbaaa -> abbbbbaaba

# < a,b | babbbbbabaaaaa=a >
babbbbbabaaaaa -> a

# < a,b | babbbbbabaaaba=a >
babbbbbabaaaba -> a
babbbbbabaaaa -> abbbbbabaaaba

# < a,b | babbbbbabaabaa=a >
babbbbbabaabaa -> a

# < a,b | babbbbbabaabba=a >
babbbbbabaabba -> a
babbbbbabaaba -> abbbbbabaabba
babbbbbabaaa -> abbbbbabaaba

# < a,b | babbbbbababaaa=a >
babbbbbababaaa -> a

# < a,b | babbbbbabababa=a >
babbbbbabababa -> a
babbbbbababaa -> abbbbbabababa

# < a,b | babbbbbababbaa=a >
babbbbbababbaa -> a

# < a,b | babbbbbababbba=a >
babbbbbababbba -> a
babbbbbababba -> abbbbbababbba
babbbbbababa -> abbbbbababba
babbbbbabaa -> abbbbbababa

# < a,b | babbbbbabbaaaa=a >
babbbbbabbaaaa -> a

# < a,b | babbbbbabbaaba=a >
babbbbbabbaaba -> a
babbbbbabbaaa -> abbbbbabbaaba

# < a,b | babbbbbabbabaa=a >
babbbbbabbabaa -> a

# < a,b | babbbbbabbabba=a >
babbbbbabbabba -> a
babbbbbabbaba -> abbbbbabbabba
babbbbbabbaa -> abbbbbabbaba

# < a,b | babbbbbabbbaaa=a >
babbbbbabbbaaa -> a

# < a,b | babbbbbabbbaba=a >
babbbbbabbbaba -> a
babbbbbabbbaa -> abbbbbabbbaba

# < a,b | babbbbbabbbbaa=a >
babbbbbabbbbaa -> a

# < a,b | babbbbbabbbbba=a >
babbbbbabbbbba -> a
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | babbbbbbaaaaaa=a >
babbbbbbaaaaaa -> a

# < a,b | babbbbbbaaaaba=a >
babbbbbbaaaaba -> a
babbbbbbaaaaa -> abbbbbbaaaaba

# < a,b | babbbbbbaaabaa=a >
babbbbbbaaabaa -> a

# < a,b | babbbbbbaaabba=a >
babbbbbbaaabba -> a
babbbbbbaaaba -> abbbbbbaaabba
babbbbbbaaaa -> abbbbbbaaaba

# < a,b | babbbbbbaabaaa=a >
babbbbbbaabaaa -> a

# < a,b | babbbbbbaababa=a >
babbbbbbaababa -> a
babbbbbbaabaa -> abbbbbbaababa

# < a,b | babbbbbbaabbaa=a >
babbbbbbaabbaa -> a

# < a,b | babbbbbbaabbba=a >
babbbbbbaabbba -> a
babbbbbbaabba -> abbbbbbaabbba
babbbbbbaaba -> abbbbbbaabba
babbbbbbaaa -> abbbbbbaaba

# < a,b | babbbbbbabaaaa=a >
babbbbbbabaaaa -> a

# < a,b | babbbbbbabaaba=a >
babbbbbbabaaba -> a
babbbbbbabaaa -> abbbbbbabaaba

# < a,b | babbbbbbababaa=a >
babbbbbbababaa -> a

# < a,b | babbbbbbababba=a >
babbbbbbababba -> a
babbbbbbababa -> abbbbbbababba
babbbbbbabaa -> abbbbbbababa

# < a,b | babbbbbbabbaaa=a >
babbbbbbabbaaa -> a

# < a,b | babbbbbbabbaba=a >
babbbbbbabbaba -> a
babbbbbbabbaa -> abbbbbbabbaba

# < a,b | babbbbbbabbbaa=a >
babbbbbbabbbaa -> a

# < a,b | babbbbbbabbbba=a >
babbbbbbabbbba -> a
babbbbbbabbba -> abbbbbbabbbba
babbbbbbabba -> abbbbbbabbba
babbbbbbaba -> abbbbbbabba
babbbbbbaa -> abbbbbbaba

# < a,b | babbbbbbbaaaaa=a >
babbbbbbbaaaaa -> a

# < a,b | babbbbbbbaaaba=a >
babbbbbbbaaaba -> a
babbbbbbbaaaa -> abbbbbbbaaaba

# < a,b | babbbbbbbaabaa=a >
babbbbbbbaabaa -> a

# < a,b | babbbbbbbaabba=a >
babbbbbbbaabba -> a
babbbbbbbaaba -> abbbbbbbaabba
babbbbbbbaaa -> abbbbbbbaaba

# < a,b | babbbbbbbabaaa=a >
babbbbbbbabaaa -> a

# < a,b | babbbbbbbababa=a >
babbbbbbbababa -> a
babbbbbbbabaa -> abbbbbbbababa

# < a,b | babbbbbbbabbaa=a >
babbbbbbbabbaa -> a

# < a,b | babbbbbbbabbba=a >
babbbbbbbabbba -> a
babbbbbbbabba -> abbbbbbbabbba
babbbbbbbaba -> abbbbbbbabba
babbbbbbbaa -> abbbbbbbaba

# < a,b | babbbbbbbbaaaa=a >
babbbbbbbbaaaa -> a

# < a,b | babbbbbbbbaaba=a >
babbbbbbbbaaba -> a
babbbbbbbbaaa -> abbbbbbbbaaba

# < a,b | babbbbbbbbabaa=a >
babbbbbbbbabaa -> a

# < a,b | babbbbbbbbabba=a >
babbbbbbbbabba -> a
babbbbbbbbaba -> abbbbbbbbabba
babbbbbbbbaa -> abbbbbbbbaba

# < a,b | babbbbbbbbbaaa=a >
babbbbbbbbbaaa -> a

# < a,b | babbbbbbbbbaba=a >
babbbbbbbbbaba -> a
babbbbbbbbbaa -> abbbbbbbbbaba

# < a,b | babbbbbbbbbbaa=a >
babbbbbbbbbbaa -> a

# < a,b | babbbbbbbbbbba=a >
babbbbbbbbbbba -> a
babbbbbbbbbba -> abbbbbbbbbbba
babbbbbbbbba -> abbbbbbbbbba
babbbbbbbba -> abbbbbbbbba
babbbbbbba -> abbbbbbbba
babbbbbba -> abbbbbbba
babbbbba -> abbbbbba
babbbba -> abbbbba
babbba -> abbbba
babba -> abbba
baba -> abba
baa -> aba

# < a,b | bbaaaaaaaaaaaa=a >
bbaaaaaaaaaaaa -> a

# < a,b | bbaaaaaaaaaaba=a >
bbaaaaaaaaaaba -> a

# < a,b | bbaaaaaaaaabaa=a >
bbaaaaaaaaabaa -> a

# < a,b | bbaaaaaaaaabba=a >
bbaaaaaaaaabba -> a
bbaaaaaaaaaa -> aaaaaaaaabba

# < a,b | bbaaaaaaaabaaa=a >
bbaaaaaaaabaaa -> a

# < a,b | bbaaaaaaaababa=a >
bbaaaaaaaababa -> a

# < a,b | bbaaaaaaaabbaa=a >
bbaaaaaaaabbaa -> a
bbaaaaaaaaa -> aaaaaaabbaa

# < a,b | bbaaaaaaaabbba=a >
bbaaaaaaaabbba -> a
bbaaaaaaaaba -> aaaaaaaabbba

# < a,b | bbaaaaaaabaaaa=a >
bbaaaaaaabaaaa -> a

# < a,b | bbaaaaaaabaaba=a >
bbaaaaaaabaaba -> a

# < a,b | bbaaaaaaababaa=a >
bbaaaaaaababaa -> a

# < a,b | bbaaaaaaababba=a >
bbaaaaaaababba -> a
bbaaaaaaabaa -> aaaaaaababba

# < a,b | bbaaaaaaabbaaa=a >
bbaaaaaaabbaaa -> a
bbaaaaaaaa -> aaaaabbaaa

# < a,b | bbaaaaaaabbaba=a >
bbaaaaaaabbaba -> a

# < a,b | bbaaaaaaabbbaa=a >
bbaaaaaaabbbaa -> a
bbaaaaaaaba -> aaaaaabbbaa

# < a,b | bbaaaaaaabbbba=a >
bbaaaaaaabbbba -> a
bbaaaaaaabba -> aaaaaaabbbba
bbaaaaaaaa -> aaaaaaabba

# < a,b | bbaaaaaabaaaaa=a >
bbaaaaaabaaaaa -> a

# < a,b | bbaaaaaabaaaba=a >
bbaaaaaabaaaba -> a

# < a,b | bbaaaaaabaabaa=a >
bbaaaaaabaabaa -> a

# < a,b | bbaaaaaabaabba=a >
bbaaaaaabaabba -> a
bbaaaaaabaaa -> aaaaaabaabba

# < a,b | bbaaaaaababaaa=a >
bbaaaaaababaaa -> a

# < a,b | bbaaaaaabababa=a >
bbaaaaaabababa -> a

# < a,b | bbaaaaaababbaa=a >
bbaaaaaababbaa -> a
bbaaaaaabaa -> aaaaababbaa

# < a,b | bbaaaaaababbba=a >
bbaaaaaababbba -> a
bbaaaaaababa -> aaaaaababbba

# < a,b | bbaaaaaabbaaaa=a >
bbaaaaaabbaaaa -> a
bbaaaaaaa -> aaabbaaaa

# < a,b | bbaaaaaabbaaba=a >
bbaaaaaabbaaba -> a

# < a,b | bbaaaaaabbabaa=a >
bbaaaaaabbabaa -> a

# < a,b | bbaaaaaabbbaaa=a >
bbaaaaaabbbaaa -> a
bbaaaaaaba -> aaaabbbaaa

# < a,b | bbaaaaaabbbaba=a >
bbaaaaaabbbaba -> a

# < a,b | bbaaaaaabbbbba=a >
bbaaaaaabbbbba -> a
bbaaaaaabbba -> aaaaaabbbbba
bbaaaaaaba -> aaaaaabbba

# < a,b | bbaaaaabaaaaaa=a >
bbaaaaabaaaaaa -> a

# < a,b | bbaaaaabaaaaba=a >
bbaaaaabaaaaba -> a

# < a,b | bbaaaaabaaabaa=a >
bbaaaaabaaabaa -> a

# < a,b | bbaaaaabaaabba=a >
bbaaaaabaaabba -> a
bbaaaaabaaaa -> aaaaabaaabba

# < a,b | bbaaaaabaabaaa=a >
bbaaaaabaabaaa -> a

# < a,b | bbaaaaabaababa=a >
bbaaaaabaababa -> a

# < a,b | bbaaaaabaabbaa=a >
bbaaaaabaabbaa -> a
bbaaaaabaaa -> aaaabaabbaa

# < a,b | bbaaaaabaabbba=a >
bbaaaaabaabbba -> a
bbaaaaabaaba -> aaaaabaabbba

# < a,b | bbaaaaababaaaa=a >
bbaaaaababaaaa -> a

# < a,b | bbaaaaababaaba=a >
bbaaaaababaaba -> a

# < a,b | bbaaaaabababaa=a >
bbaaaaabababaa -> a

# < a,b | bbaaaaabababba=a >
bbaaaaabababba -> a
bbaaaaababaa -> aaaaabababba

# < a,b | bbaaaaababbaaa=a >
bbaaaaababbaaa -> a
bbaaaaabaa -> aaababbaaa

# < a,b | bbaaaaababbaba=a >
bbaaaaababbaba -> a

# < a,b | bbaaaaababbbaa=a >
bbaaaaababbbaa -> a
bbaaaaababa -> aaaababbbaa

# < a,b | bbaaaaababbbba=a >
bbaaaaababbbba -> a
bbaaaaababba -> aaaaababbbba
bbaaaaabaa -> aaaaababba

# < a,b | bbaaaaabbaaaaa=a >
bbaaaaabbaaaaa -> a
bbaaaaaa -> abbaaaaa

# < a,b | bbaaaaabbaaaba=a >
bbaaaaabbaaaba -> a

# < a,b | bbaaaaabbaabaa=a >
bbaaaaabbaabaa -> a

# < a,b | bbaaaaabbabaaa=a >
bbaaaaabbabaaa -> a

# < a,b | bbaaaaabbababa=a >
bbaaaaabbababa -> a

# < a,b | bbaaaaabbabbaa=a >
bbaaaaabbabbaa -> a
bbaaaaabbaa -> aaaabbabbaa
bbaaaaaa -> aaaabbaa

# < a,b | bbaaaaabbabbba=a >
bbaaaaabbabbba -> a
bbaaaaabbaba -> aaaaabbabbba

# < a,b | bbaaaaabbbaaaa=a >
bbaaaaabbbaaaa -> a
bbaaaaaba -> aabbbaaaa

# < a,b | bbaaaaabbbaaba=a >
bbaaaaabbbaaba -> a

# < a,b | bbaaaaabbbabaa=a >
bbaaaaabbbabaa -> a

# < a,b | bbaaaaabbbbaba=a >
bbaaaaabbbbaba -> a

# < a,b | bbaaaaabbbbbba=a >
bbaaaaabbbbbba -> a
bbaaaaabbbba -> aaaaabbbbbba
bbaaaaabba -> aaaaabbbba
bbaaaaaa -> aaaaabba

# < a,b | bbaaaabaaaaaaa=a >
bbaaaabaaaaaaa -> a

# < a,b | bbaaaabaaaaaba=a >
bbaaaabaaaaaba -> a

# < a,b | bbaaaabaaaabaa=a >
bbaaaabaaaabaa -> a

# < a,b | bbaaaabaaaabba=a >
bbaaaabaaaabba -> a
bbaaaabaaaaa -> aaaabaaaabba

# < a,b | bbaaaabaaabaaa=a >
bbaaaabaaabaaa -> a

# < a,b | bbaaaabaaababa=a >
bbaaaabaaababa -> a

# < a,b | bbaaaabaaabbaa=a >
bbaaaabaaabbaa -> a
bbaaaabaaaa -> aaabaaabbaa

# < a,b | bbaaaabaaabbba=a >
bbaaaabaaabbba -> a
bbaaaabaaaba -> aaaabaaabbba

# < a,b | bbaaaabaabaaaa=a >
bbaaaabaabaaaa -> a

# < a,b | bbaaaabaabaaba=a >
bbaaaabaabaaba -> a

# < a,b | bbaaaabaababaa=a >
bbaaaabaababaa -> a

# < a,b | bbaaaabaababba=a >
bbaaaabaababba -> a
bbaaaabaabaa -> aaaabaababba

# < a,b | bbaaaabaabbaaa=a >
bbaaaabaabbaaa -> a
bbaaaabaaa -> aabaabbaaa

# < a,b | bbaaaabaabbaba=a >
bbaaaabaabbaba -> a

# < a,b | bbaaaabaabbbaa=a >
bbaaaabaabbbaa -> a
bbaaaabaaba -> aaabaabbbaa

# < a,b | bbaaaabaabbbba=a >
bbaaaabaabbbba -> a
bbaaaabaabba -> aaaabaabbbba
bbaaaabaaa -> aaaabaabba

# < a,b | bbaaaababaaaaa=a >
bbaaaababaaaaa -> a

# < a,b | bbaaaababaaaba=a >
bbaaaababaaaba -> a

# < a,b | bbaaaababaabaa=a >
bbaaaababaabaa -> a

# < a,b | bbaaaababaabba=a >
bbaaaababaabba -> a
bbaaaababaaa -> aaaababaabba

# < a,b | bbaaaabababaaa=a >
bbaaaabababaaa -> a

# < a,b | bbaaaababababa=a >
bbaaaababababa -> a

# < a,b | bbaaaabababbaa=a >
bbaaaabababbaa -> a
bbaaaababaa -> aaabababbaa

# < a,b | bbaaaabababbba=a >
bbaaaabababbba -> a
bbaaaabababa -> aaaabababbba

# < a,b | bbaaaababbaaaa=a >
bbaaaababbaaaa -> a
bbaaaabaa -> ababbaaaa

# < a,b | bbaaaababbaaba=a >
bbaaaababbaaba -> a

# < a,b | bbaaaababbabaa=a >
bbaaaababbabaa -> a

# < a,b | bbaaaababbbaaa=a >
bbaaaababbbaaa -> a
bbaaaababa -> aababbbaaa

# < a,b | bbaaaababbbaba=a >
bbaaaababbbaba -> a

# < a,b | bbaaaababbbbba=a >
bbaaaababbbbba -> a
bbaaaababbba -> aaaababbbbba
bbaaaababa -> aaaababbba

# < a,b | bbaaaabbaaaaaa=a >
bbaaaabbaaaaaa -> a

# < a,b | bbaaaabbaaaaba=a >
bbaaaabbaaaaba -> a

# < a,b | bbaaaabbaaabaa=a >
bbaaaabbaaabaa -> a

# < a,b | bbaaaabbaabaaa=a >
bbaaaabbaabaaa -> a

# < a,b | bbaaaabbaababa=a >
bbaaaabbaababa -> a

# < a,b | bbaaaabbaabbba=a >
bbaaaabbaabbba -> a
bbaaaabbaaba -> aaaabbaabbba

# < a,b | bbaaaabbabaaaa=a >
bbaaaabbabaaaa -> a

# < a,b | bbaaaabbabaaba=a >
bbaaaabbabaaba -> a

# < a,b | bbaaaabbababaa=a >
bbaaaabbababaa -> a

# < a,b | bbaaaabbababba=a >
bbaaaabbababba -> a
bbaaaabbabaa -> aaaabbababba

# < a,b | bbaaaabbabbaba=a >
bbaaaabbabbaba -> a

# < a,b | bbaaaabbabbbaa=a >
bbaaaabbabbbaa -> a
bbaaaabbaba -> aaabbabbbaa

# < a,b | bbaaaabbbaaaaa=a >
bbaaaabbbaaaaa -> a

# < a,b | bbaaaabbbaaaba=a >
bbaaaabbbaaaba -> a

# < a,b | bbaaaabbbaabaa=a >
bbaaaabbbaabaa -> a

# < a,b | bbaaaabbbabaaa=a >
bbaaaabbbabaaa -> a

# < a,b | bbaaaabbbababa=a >
bbaaaabbbababa -> a

# < a,b | bbaaaabbbabbaa=a >
bbaaaabbbabbaa -> a
bbaaaabbbaa -> aaabbbabbaa
bbaaaaba -> aaabbbaa

# < a,b | bbaaaabbbabbba=a >
bbaaaabbbabbba -> a
bbaaaabbbaba -> aaaabbbabbba

# < a,b | bbaaaabbbbaaba=a >
bbaaaabbbbaaba -> a

# < a,b | bbaaaabbbbabaa=a >
bbaaaabbbbabaa -> a

# < a,b | bbaaaabbbbbaba=a >
bbaaaabbbbbaba -> a

# < a,b | bbaaaabbbbbbba=a >
bbaaaabbbbbbba -> a
bbaaaabbbbba -> aaaabbbbbbba
bbaaaabbba -> aaaabbbbba
bbaaaaba -> aaaabbba

# < a,b | bbaaabaaaaaaaa=a >
bbaaabaaaaaaaa -> a

# < a,b | bbaaabaaaaaaba=a >
bbaaabaaaaaaba -> a

# < a,b | bbaaabaaaaabaa=a >
bbaaabaaaaabaa -> a

# < a,b | bbaaabaaaaabba=a >
bbaaabaaaaabba -> a
bbaaabaaaaaa -> aaabaaaaabba

# < a,b | bbaaabaaaabaaa=a >
bbaaabaaaabaaa -> a

# < a,b | bbaaabaaaababa=a >
bbaaabaaaababa -> a

# < a,b | bbaaabaaaabbaa=a >
bbaaabaaaabbaa -> a
bbaaabaaaaa -> aabaaaabbaa

# < a,b | bbaaabaaaabbba=a >
bbaaabaaaabbba -> a
bbaaabaaaaba -> aaabaaaabbba

# < a,b | bbaaabaaabaaaa=a >
bbaaabaaabaaaa -> a

# < a,b | bbaaabaaabaaba=a >
bbaaabaaabaaba -> a

# < a,b | bbaaabaaababaa=a >
bbaaabaaababaa -> a

# < a,b | bbaaabaaababba=a >
bbaaabaaababba -> a
bbaaabaaabaa -> aaabaaababba

# < a,b | bbaaabaaabbaaa=a >
bbaaabaaabbaaa -> a
bbaaabaaaa -> abaaabbaaa

# < a,b | bbaaabaaabbaba=a >
bbaaabaaabbaba -> a

# < a,b | bbaaabaaabbbaa=a >
bbaaabaaabbbaa -> a
bbaaabaaaba -> aabaaabbbaa

# < a,b | bbaaabaaabbbba=a >
bbaaabaaabbbba -> a
bbaaabaaabba -> aaabaaabbbba
bbaaabaaaa -> aaabaaabba

# < a,b | bbaaabaabaaaaa=a >
bbaaabaabaaaaa -> a

# < a,b | bbaaabaabaaaba=a >
bbaaabaabaaaba -> a

# < a,b | bbaaabaabaabaa=a >
bbaaabaabaabaa -> a

# < a,b | bbaaabaabaabba=a >
bbaaabaabaabba -> a
bbaaabaabaaa -> aaabaabaabba

# < a,b | bbaaabaababaaa=a >
bbaaabaababaaa -> a

# < a,b | bbaaabaabababa=a >
bbaaabaabababa -> a

# < a,b | bbaaabaababbaa=a >
bbaaabaababbaa -> a
bbaaabaabaa -> aabaababbaa

# < a,b | bbaaabaababbba=a >
bbaaabaababbba -> a
bbaaabaababa -> aaabaababbba

# < a,b | bbaaabaabbaaaa=a >
bbaaabaabbaaaa -> a

# < a,b | bbaaabaabbaaba=a >
bbaaabaabbaaba -> a

# < a,b | bbaaabaabbabaa=a >
bbaaabaabbabaa -> a

# < a,b | bbaaabaabbbaaa=a >
bbaaabaabbbaaa -> a
bbaaabaaba -> abaabbbaaa

# < a,b | bbaaabaabbbaba=a >
bbaaabaabbbaba -> a

# < a,b | bbaaabaabbbbba=a >
bbaaabaabbbbba -> a
bbaaabaabbba -> aaabaabbbbba
bbaaabaaba -> aaabaabbba

# < a,b | bbaaababaaaaaa=a >
bbaaababaaaaaa -> a

# < a,b | bbaaababaaaaba=a >
bbaaababaaaaba -> a

# < a,b | bbaaababaaabaa=a >
bbaaababaaabaa -> a

# < a,b | bbaaababaaabba=a >
bbaaababaaabba -> a
bbaaababaaaa -> aaababaaabba

# < a,b | bbaaababaabaaa=a >
bbaaababaabaaa -> a

# < a,b | bbaaababaababa=a >
bbaaababaababa -> a

# < a,b | bbaaababaabbaa=a >
bbaaababaabbaa -> a
bbaaababaaa -> aababaabbaa

# < a,b | bbaaababaabbba=a >
bbaaababaabbba -> a
bbaaababaaba -> aaababaabbba

# < a,b | bbaaabababaaaa=a >
bbaaabababaaaa -> a

# < a,b | bbaaabababaaba=a >
bbaaabababaaba -> a

# < a,b | bbaaababababaa=a >
bbaaababababaa -> a

# < a,b | bbaaababababba=a >
bbaaababababba -> a
bbaaabababaa -> aaababababba

# < a,b | bbaaabababbaaa=a >
bbaaabababbaaa -> a
bbaaababaa -> abababbaaa

# < a,b | bbaaabababbaba=a >
bbaaabababbaba -> a

# < a,b | bbaaabababbbaa=a >
bbaaabababbbaa -> a
bbaaabababa -> aabababbbaa

# < a,b | bbaaabababbbba=a >
bbaaabababbbba -> a
bbaaabababba -> aaabababbbba
bbaaababaa -> aaabababba

# < a,b | bbaaababbaaaaa=a >
bbaaababbaaaaa -> a

# < a,b | bbaaababbaaaba=a >
bbaaababbaaaba -> a
bbaaabaa -> abbaaaba

# < a,b | bbaaababbaabaa=a >
bbaaababbaabaa -> a

# < a,b | bbaaababbabaaa=a >
bbaaababbabaaa -> a

# < a,b | bbaaababbababa=a >
bbaaababbababa -> a

# < a,b | bbaaababbabbaa=a >
bbaaababbabbaa -> a
bbaaababbaa -> aababbabbaa
bbaaabaa -> aababbaa

# < a,b | bbaaababbabbba=a >
bbaaababbabbba -> a
bbaaababbaba -> aaababbabbba

# < a,b | bbaaababbbaaaa=a >
bbaaababbbaaaa -> a

# < a,b | bbaaababbbaaba=a >
bbaaababbbaaba -> a

# < a,b | bbaaababbbabaa=a >
bbaaababbbabaa -> a

# < a,b | bbaaababbbbaba=a >
bbaaababbbbaba -> a

# < a,b | bbaaababbbbbba=a >
bbaaababbbbbba -> a
bbaaababbbba -> aaababbbbbba
bbaaababba -> aaababbbba
bbaaabaa -> aaababba

# < a,b | bbaaabbaaaaaaa=a >
bbaaabbaaaaaaa -> a

# < a,b | bbaaabbaaaaaba=a >
bbaaabbaaaaaba -> a

# < a,b | bbaaabbaaaabaa=a >
bbaaabbaaaabaa -> a

# < a,b | bbaaabbaaaabba=a >
bbaaabbaaaabba -> a
bbaaabbaaaaa -> aaabbaaaabba

# < a,b | bbaaabbaaabaaa=a >
bbaaabbaaabaaa -> a

# < a,b | bbaaabbaaababa=a >
bbaaabbaaababa -> a

# < a,b | bbaaabbaaabbaa=a >
bbaaabbaaabbaa -> a
bbaaaa -> aabbaa

# < a,b | bbaaabbaaabbba=a >
bbaaabbaaabbba -> a
bbaaabbaaaba -> aaabbaaabbba

# < a,b | bbaaabbaabaaaa=a >
bbaaabbaabaaaa -> a

# < a,b | bbaaabbaabaaba=a >
bbaaabbaabaaba -> a

# < a,b | bbaaabbaababaa=a >
bbaaabbaababaa -> a

# < a,b | bbaaabbaababba=a >
bbaaabbaababba -> a
bbaaabbaabaa -> aaabbaababba

# < a,b | bbaaabbaabbaaa=a >
bbaaabbaabbaaa -> a
bbaaabbaaa -> abbaabbaaa
bbaaaa -> abbaaa

# < a,b | bbaaabbaabbaba=a >
bbaaabbaabbaba -> a

# < a,b | bbaaabbaabbbaa=a >
bbaaabbaabbbaa -> a
bbaaabbaaba -> aabbaabbbaa

# < a,b | bbaaabbabaaaaa=a >
bbaaabbabaaaaa -> a

# < a,b | bbaaabbabaaaba=a >
bbaaabbabaaaba -> a

# < a,b | bbaaabbabaabaa=a >
bbaaabbabaabaa -> a

# < a,b | bbaaabbabaabba=a >
bbaaabbabaabba -> a
bbaaabbabaaa -> aaabbabaabba

# < a,b | bbaaabbababaaa=a >
bbaaabbababaaa -> a

# < a,b | bbaaabbabababa=a >
bbaaabbabababa -> a

# < a,b | bbaaabbababbaa=a >
bbaaabbababbaa -> a
bbaaabbabaa -> aabbababbaa

# < a,b | bbaaabbababbba=a >
bbaaabbababbba -> a
bbaaabbababa -> aaabbababbba

# < a,b | bbaaabbabbaaaa=a >
bbaaabbabbaaaa -> a

# < a,b | bbaaabbabbaaba=a >
bbaaabbabbaaba -> a

# < a,b | bbaaabbabbabaa=a >
bbaaabbabbabaa -> a

# < a,b | bbaaabbabbbaaa=a >
bbaaabbabbbaaa -> a
bbaaabbaba -> abbabbbaaa

# < a,b | bbaaabbabbbaba=a >
bbaaabbabbbaba -> a

# < a,b | bbaaabbabbbbba=a >
bbaaabbabbbbba -> a
bbaaabbabbba -> aaabbabbbbba
bbaaabbaba -> aaabbabbba

# < a,b | bbaaabbbaaaaaa=a >
bbaaabbbaaaaaa -> a

# < a,b | bbaaabbbaaaaba=a >
bbaaabbbaaaaba -> a

# < a,b | bbaaabbbaaabaa=a >
bbaaabbbaaabaa -> a

# < a,b | bbaaabbbaaabba=a >
bbaaabbbaaabba -> a
bbaaabbbaaaa -> aaabbbaaabba

# < a,b | bbaaabbbaabaaa=a >
bbaaabbbaabaaa -> a

# < a,b | bbaaabbbaababa=a >
bbaaabbbaababa -> a

# < a,b | bbaaabbbaabbba=a >
bbaaabbbaabbba -> a
bbaaabbbaaba -> aaabbbaabbba

# < a,b | bbaaabbbabaaaa=a >
bbaaabbbabaaaa -> a

# < a,b | bbaaabbbabaaba=a >
bbaaabbbabaaba -> a

# < a,b | bbaaabbbababaa=a >
bbaaabbbababaa -> a

# < a,b | bbaaabbbababba=a >
bbaaabbbababba -> a
bbaaabbbabaa -> aaabbbababba

# < a,b | bbaaabbbabbaba=a >
bbaaabbbabbaba -> a

# < a,b | bbaaabbbabbbaa=a >
bbaaabbbabbbaa -> a
bbaaabbbaba -> aabbbabbbaa

# < a,b | bbaaabbbbaaaaa=a >
bbaaabbbbaaaaa -> a

# < a,b | bbaaabbbbaaaba=a >
bbaaabbbbaaaba -> a

# < a,b | bbaaabbbbaabaa=a >
bbaaabbbbaabaa -> a

# < a,b | bbaaabbbbabaaa=a >
bbaaabbbbabaaa -> a

# < a,b | bbaaabbbbababa=a >
bbaaabbbbababa -> a

# < a,b | bbaaabbbbabbba=a >
bbaaabbbbabbba -> a
bbaaabbbbaba -> aaabbbbabbba

# < a,b | bbaaabbbbbaaaa=a >
bbaaabbbbbaaaa -> a

# < a,b | bbaaabbbbbaaba=a >
bbaaabbbbbaaba -> a

# < a,b | bbaaabbbbbabaa=a >
bbaaabbbbbabaa -> a

# < a,b | bbaaabbbbbbaba=a >
bbaaabbbbbbaba -> a

# < a,b | bbaaabbbbbbbba=a >
bbaaabbbbbbbba -> a
bbaaabbbbbba -> aaabbbbbbbba
bbaaabbbba -> aaabbbbbba
bbaaabba -> aaabbbba
bbaaaa -> aaabba

# < a,b | bbaabaaaaaaaaa=a >
bbaabaaaaaaaaa -> a

# < a,b | bbaabaaaaaaaba=a >
bbaabaaaaaaaba -> a

# < a,b | bbaabaaaaaabaa=a >
bbaabaaaaaabaa -> a

# < a,b | bbaabaaaaaabba=a >
bbaabaaaaaabba -> a
bbaabaaaaaaa -> aabaaaaaabba

# < a,b | bbaabaaaaabaaa=a >
bbaabaaaaabaaa -> a

# < a,b | bbaabaaaaababa=a >
bbaabaaaaababa -> a

# < a,b | bbaabaaaaabbaa=a >
bbaabaaaaabbaa -> a
bbaabaaaaaa -> abaaaaabbaa

# < a,b | bbaabaaaaabbba=a >
bbaabaaaaabbba -> a
bbaabaaaaaba -> aabaaaaabbba

# < a,b | bbaabaaaabaaaa=a >
bbaabaaaabaaaa -> a

# < a,b | bbaabaaaabaaba=a >
bbaabaaaabaaba -> a

# < a,b | bbaabaaaababaa=a >
bbaabaaaababaa -> a

# < a,b | bbaabaaaababba=a >
bbaabaaaababba -> a
bbaabaaaabaa -> aabaaaababba

# < a,b | bbaabaaaabbaaa=a >
bbaabaaaabbaaa -> a

# < a,b | bbaabaaaabbaba=a >
bbaabaaaabbaba -> a

# < a,b | bbaabaaaabbbaa=a >
bbaabaaaabbbaa -> a
bbaabaaaaba -> abaaaabbbaa

# < a,b | bbaabaaaabbbba=a >
bbaabaaaabbbba -> a
bbaabaaaabba -> aabaaaabbbba
bbaabaaaaa -> aabaaaabba

# < a,b | bbaabaaabaaaaa=a >
bbaabaaabaaaaa -> a

# < a,b | bbaabaaabaaaba=a >
bbaabaaabaaaba -> a

# < a,b | bbaabaaabaabaa=a >
bbaabaaabaabaa -> a

# < a,b | bbaabaaabaabba=a >
bbaabaaabaabba -> a
bbaabaaabaaa -> aabaaabaabba

# < a,b | bbaabaaababaaa=a >
bbaabaaababaaa -> a

# < a,b | bbaabaaabababa=a >
bbaabaaabababa -> a

# < a,b | bbaabaaababbaa=a >
bbaabaaababbaa -> a
bbaabaaabaa -> abaaababbaa

# < a,b | bbaabaaababbba=a >
bbaabaaababbba -> a
bbaabaaababa -> aabaaababbba

# < a,b | bbaabaaabbaaaa=a >
bbaabaaabbaaaa -> a

# < a,b | bbaabaaabbaaba=a >
bbaabaaabbaaba -> a
bbaabaaaa -> aaabbaaba

# < a,b | bbaabaaabbabaa=a >
bbaabaaabbabaa -> a

# < a,b | bbaabaaabbbaaa=a >
bbaabaaabbbaaa -> a

# < a,b | bbaabaaabbbaba=a >
bbaabaaabbbaba -> a

# < a,b | bbaabaaabbbbba=a >
bbaabaaabbbbba -> a
bbaabaaabbba -> aabaaabbbbba
bbaabaaaba -> aabaaabbba

# < a,b | bbaabaabaaaaaa=a >
bbaabaabaaaaaa -> a

# < a,b | bbaabaabaaaaba=a >
bbaabaabaaaaba -> a

# < a,b | bbaabaabaaabaa=a >
bbaabaabaaabaa -> a

# < a,b | bbaabaabaaabba=a >
bbaabaabaaabba -> a
bbaabaabaaaa -> aabaabaaabba

# < a,b | bbaabaabaabaaa=a >
bbaabaabaabaaa -> a

# < a,b | bbaabaabaababa=a >
bbaabaabaababa -> a

# < a,b | bbaabaabaabbaa=a >
bbaabaabaabbaa -> a
bbaabaabaaa -> abaabaabbaa

# < a,b | bbaabaabaabbba=a >
bbaabaabaabbba -> a
bbaabaabaaba -> aabaabaabbba

# < a,b | bbaabaababaaaa=a >
bbaabaababaaaa -> a

# < a,b | bbaabaababaaba=a >
bbaabaababaaba -> a

# < a,b | bbaabaabababaa=a >
bbaabaabababaa -> a

# < a,b | bbaabaabababba=a >
bbaabaabababba -> a
bbaabaababaa -> aabaabababba

# < a,b | bbaabaababbaaa=a >
bbaabaababbaaa -> a

# < a,b | bbaabaababbaba=a >
bbaabaababbaba -> a

# < a,b | bbaabaababbbaa=a >
bbaabaababbbaa -> a
bbaabaababa -> abaababbbaa

# < a,b | bbaabaababbbba=a >
bbaabaababbbba -> a
bbaabaababba -> aabaababbbba
bbaabaabaa -> aabaababba

# < a,b | bbaabaabbaaaaa=a >
bbaabaabbaaaaa -> a

# < a,b | bbaabaabbaaaba=a >
bbaabaabbaaaba -> a

# < a,b | bbaabaabbaabaa=a >
bbaabaabbaabaa -> a
bbaabaaa -> abbaabaa

# < a,b | bbaabaabbaabba=a >
bbaabaabbaabba -> a
bbaabaabbaaa -> aabaabbaabba

# < a,b | bbaabaabbabaaa=a >
bbaabaabbabaaa -> a

# < a,b | bbaabaabbababa=a >
bbaabaabbababa -> a

# < a,b | bbaabaabbabbaa=a >
bbaabaabbabbaa -> a
bbaabaabbaa -> abaabbabbaa
bbaabaaa -> abaabbaa

# < a,b | bbaabaabbabbba=a >
bbaabaabbabbba -> a
bbaabaabbaba -> aabaabbabbba

# < a,b | bbaabaabbbaaaa=a >
bbaabaabbbaaaa -> a

# < a,b | bbaabaabbbaaba=a >
bbaabaabbbaaba -> a
bbaabaaba -> aabbbaaba

# < a,b | bbaabaabbbabaa=a >
bbaabaabbbabaa -> a

# < a,b | bbaabaabbbbaaa=a >
bbaabaabbbbaaa -> a

# < a,b | bbaabaabbbbaba=a >
bbaabaabbbbaba -> a

# < a,b | bbaabaabbbbbba=a >
bbaabaabbbbbba -> a
bbaabaabbbba -> aabaabbbbbba
bbaabaabba -> aabaabbbba
bbaabaaa -> aabaabba

# < a,b | bbaababaaaaaaa=a >
bbaababaaaaaaa -> a

# < a,b | bbaababaaaaaba=a >
bbaababaaaaaba -> a

# < a,b | bbaababaaaabaa=a >
bbaababaaaabaa -> a

# < a,b | bbaababaaaabba=a >
bbaababaaaabba -> a
bbaababaaaaa -> aababaaaabba

# < a,b | bbaababaaabaaa=a >
bbaababaaabaaa -> a

# < a,b | bbaababaaababa=a >
bbaababaaababa -> a

# < a,b | bbaababaaabbaa=a >
bbaababaaabbaa -> a
bbaababaaaa -> ababaaabbaa

# < a,b | bbaababaaabbba=a >
bbaababaaabbba -> a
bbaababaaaba -> aababaaabbba

# < a,b | bbaababaabaaaa=a >
bbaababaabaaaa -> a

# < a,b | bbaababaabaaba=a >
bbaababaabaaba -> a

# < a,b | bbaababaababaa=a >
bbaababaababaa -> a

# < a,b | bbaababaababba=a >
bbaababaababba -> a
bbaababaabaa -> aababaababba

# < a,b | bbaababaabbaaa=a >
bbaababaabbaaa -> a

# < a,b | bbaababaabbaba=a >
bbaababaabbaba -> a

# < a,b | bbaababaabbbaa=a >
bbaababaabbbaa -> a
bbaababaaba -> ababaabbbaa

# < a,b | bbaababaabbbba=a >
bbaababaabbbba -> a
bbaababaabba -> aababaabbbba
bbaababaaa -> aababaabba

# < a,b | bbaabababaaaaa=a >
bbaabababaaaaa -> a

# < a,b | bbaabababaaaba=a >
bbaabababaaaba -> a

# < a,b | bbaabababaabaa=a >
bbaabababaabaa -> a

# < a,b | bbaabababaabba=a >
bbaabababaabba -> a
bbaabababaaa -> aabababaabba

# < a,b | bbaababababaaa=a >
bbaababababaaa -> a

# < a,b | bbaabababababa=a >
bbaabababababa -> a

# < a,b | bbaababababbaa=a >
bbaababababbaa -> a
bbaabababaa -> ababababbaa

# < a,b | bbaababababbba=a >
bbaababababbba -> a
bbaababababa -> aababababbba

# < a,b | bbaabababbaaaa=a >
bbaabababbaaaa -> a

# < a,b | bbaabababbaaba=a >
bbaabababbaaba -> a
bbaababaa -> ababbaaba

# < a,b | bbaabababbabaa=a >
bbaabababbabaa -> a

# < a,b | bbaabababbbaaa=a >
bbaabababbbaaa -> a

# < a,b | bbaabababbbaba=a >
bbaabababbbaba -> a

# < a,b | bbaabababbbbba=a >
bbaabababbbbba -> a
bbaabababbba -> aabababbbbba
bbaabababa -> aabababbba

# < a,b | bbaababbaaaaaa=a >
bbaababbaaaaaa -> a

# < a,b | bbaababbaaaaba=a >
bbaababbaaaaba -> a

# < a,b | bbaababbaaabaa=a >
bbaababbaaabaa -> a

# < a,b | bbaababbaaabba=a >
bbaababbaaabba -> a
bbaababbaaaa -> aababbaaabba

# < a,b | bbaababbaabaaa=a >
bbaababbaabaaa -> a

# < a,b | bbaababbaababa=a >
bbaababbaababa -> a

# < a,b | bbaababbaabbaa=a >
bbaababbaabbaa -> a
bbaababbaaa -> ababbaabbaa

# < a,b | bbaababbabaaaa=a >
bbaababbabaaaa -> a

# < a,b | bbaababbabaaba=a >
bbaababbabaaba -> a

# < a,b | bbaababbababaa=a >
bbaababbababaa -> a

# < a,b | bbaababbababba=a >
bbaababbababba -> a
bbaababbabaa -> aababbababba

# < a,b | bbaababbabbaaa=a >
bbaababbabbaaa -> a

# < a,b | bbaababbabbaba=a >
bbaababbabbaba -> a

# < a,b | bbaababbabbbaa=a >
bbaababbabbbaa -> a
bbaababbaba -> ababbabbbaa

# < a,b | bbaababbbaaaaa=a >
bbaababbbaaaaa -> a

# < a,b | bbaababbbaaaba=a >
bbaababbbaaaba -> a

# < a,b | bbaababbbaabaa=a >
bbaababbbaabaa -> a

# < a,b | bbaababbbaabba=a >
bbaababbbaabba -> a
bbaababbbaaa -> aababbbaabba

# < a,b | bbaababbbabaaa=a >
bbaababbbabaaa -> a

# < a,b | bbaababbbababa=a >
bbaababbbababa -> a

# < a,b | bbaababbbabbaa=a >
bbaababbbabbaa -> a
bbaababbbaa -> ababbbabbaa
bbaababa -> ababbbaa

# < a,b | bbaababbbabbba=a >
bbaababbbabbba -> a
bbaababbbaba -> aababbbabbba

# < a,b | bbaababbbbaaaa=a >
bbaababbbbaaaa -> a

# < a,b | bbaababbbbabaa=a >
bbaababbbbabaa -> a

# < a,b | bbaababbbbbaaa=a >
bbaababbbbbaaa -> a

# < a,b | bbaababbbbbaba=a >
bbaababbbbbaba -> a

# < a,b | bbaababbbbbbba=a >
bbaababbbbbbba -> a
bbaababbbbba -> aababbbbbbba
bbaababbba -> aababbbbba
bbaababa -> aababbba

# < a,b | bbaabbaaaaaaaa=a >
bbaabbaaaaaaaa -> a

# < a,b | bbaabbaaaaaaba=a >
bbaabbaaaaaaba -> a

# < a,b | bbaabbaaaaabaa=a >
bbaabbaaaaabaa -> a

# < a,b | bbaabbaaaaabba=a >
bbaabbaaaaabba -> a
bbaabbaaaaaa -> aabbaaaaabba

# < a,b | bbaabbaaaabaaa=a >
bbaabbaaaabaaa -> a

# < a,b | bbaabbaaaababa=a >
bbaabbaaaababa -> a

# < a,b | bbaabbaaaabbaa=a >
bbaabbaaaabbaa -> a
bbaabbaaaaa -> abbaaaabbaa

# < a,b | bbaabbaaaabbba=a >
bbaabbaaaabbba -> a
bbaabbaaaaba -> aabbaaaabbba

# < a,b | bbaabbaaabaaaa=a >
bbaabbaaabaaaa -> a

# < a,b | bbaabbaaabaaba=a >
bbaabbaaabaaba -> a

# < a,b | bbaabbaaababaa=a >
bbaabbaaababaa -> a

# < a,b | bbaabbaaababba=a >
bbaabbaaababba -> a
bbaabbaaabaa -> aabbaaababba

# < a,b | bbaabbaaabbaaa=a >
bbaabbaaabbaaa -> a

# < a,b | bbaabbaaabbaba=a >
bbaabbaaabbaba -> a

# < a,b | bbaabbaaabbbaa=a >
bbaabbaaabbbaa -> a
bbaabbaaaba -> abbaaabbbaa

# < a,b | bbaabbaaabbbba=a >
bbaabbaaabbbba -> a
bbaabbaaabba -> aabbaaabbbba
bbaabbaaaa -> aabbaaabba

# < a,b | bbaabbaabaaaaa=a >
bbaabbaabaaaaa -> a

# < a,b | bbaabbaabaaaba=a >
bbaabbaabaaaba -> a

# < a,b | bbaabbaabaabaa=a >
bbaabbaabaabaa -> a

# < a,b | bbaabbaabaabba=a >
bbaabbaabaabba -> a
bbaabbaabaaa -> aabbaabaabba

# < a,b | bbaabbaababaaa=a >
bbaabbaababaaa -> a

# < a,b | bbaabbaabababa=a >
bbaabbaabababa -> a

# < a,b | bbaabbaababbaa=a >
bbaabbaababbaa -> a
bbaabbaabaa -> abbaababbaa

# < a,b | bbaabbaababbba=a >
bbaabbaababbba -> a
bbaabbaababa -> aabbaababbba

# < a,b | bbaabbaabbaaaa=a >
bbaabbaabbaaaa -> a

# < a,b | bbaabbaabbaaba=a >
bbaabbaabbaaba -> a

# < a,b | bbaabbaabbabaa=a >
bbaabbaabbabaa -> a

# < a,b | bbaabbaabbbaaa=a >
bbaabbaabbbaaa -> a

# < a,b | bbaabbaabbbaba=a >
bbaabbaabbbaba -> a

# < a,b | bbaabbaabbbbba=a >
bbaabbaabbbbba -> a
bbaabbaabbba -> aabbaabbbbba
bbaabbaaba -> aabbaabbba

# < a,b | bbaabbabaaaaaa=a >
bbaabbabaaaaaa -> a

# < a,b | bbaabbabaaaaba=a >
bbaabbabaaaaba -> a

# < a,b | bbaabbabaaabaa=a >
bbaabbabaaabaa -> a

# < a,b | bbaabbabaaabba=a >
bbaabbabaaabba -> a
bbaabbabaaaa -> aabbabaaabba

# < a,b | bbaabbabaabaaa=a >
bbaabbabaabaaa -> a

# < a,b | bbaabbabaababa=a >
bbaabbabaababa -> a

# < a,b | bbaabbabaabbaa=a >
bbaabbabaabbaa -> a
bbaabbabaaa -> abbabaabbaa

# < a,b | bbaabbabaabbba=a >
bbaabbabaabbba -> a
bbaabbabaaba -> aabbabaabbba

# < a,b | bbaabbababaaaa=a >
bbaabbababaaaa -> a

# < a,b | bbaabbababaaba=a >
bbaabbababaaba -> a

# < a,b | bbaabbabababaa=a >
bbaabbabababaa -> a

# < a,b | bbaabbabababba=a >
bbaabbabababba -> a
bbaabbababaa -> aabbabababba

# < a,b | bbaabbababbaaa=a >
bbaabbababbaaa -> a

# < a,b | bbaabbababbaba=a >
bbaabbababbaba -> a

# < a,b | bbaabbababbbaa=a >
bbaabbababbbaa -> a
bbaabbababa -> abbababbbaa

# < a,b | bbaabbababbbba=a >
bbaabbababbbba -> a
bbaabbababba -> aabbababbbba
bbaabbabaa -> aabbababba

# < a,b | bbaabbabbaaaaa=a >
bbaabbabbaaaaa -> a

# < a,b | bbaabbabbaaaba=a >
bbaabbabbaaaba -> a

# < a,b | bbaabbabbaabaa=a >
bbaabbabbaabaa -> a

# < a,b | bbaabbabbabaaa=a >
bbaabbabbabaaa -> a

# < a,b | bbaabbabbababa=a >
bbaabbabbababa -> a

# < a,b | bbaabbabbabbaa=a >
bbaabbabbabbaa -> a
bbaabbabbaa -> abbabbabbaa
bbaabbaa -> abbabbaa
bbaaa -> abbaa

# < a,b | bbaabbabbabbba=a >
bbaabbabbabbba -> a
bbaabbabbaba -> aabbabbabbba

# < a,b | bbaabbabbbaaaa=a >
bbaabbabbbaaaa -> a

# < a,b | bbaabbabbbaaba=a >
bbaabbabbbaaba -> a

# < a,b | bbaabbabbbabaa=a >
bbaabbabbbabaa -> a

# < a,b | bbaabbabbbbaaa=a >
bbaabbabbbbaaa -> a

# < a,b | bbaabbabbbbaba=a >
bbaabbabbbbaba -> a

# < a,b | bbaabbbaaaaaaa=a >
bbaabbbaaaaaaa -> a

# < a,b | bbaabbbaaaaaba=a >
bbaabbbaaaaaba -> a

# < a,b | bbaabbbaaaabaa=a >
bbaabbbaaaabaa -> a

# < a,b | bbaabbbaaaabba=a >
bbaabbbaaaabba -> a
bbaabbbaaaaa -> aabbbaaaabba

# < a,b | bbaabbbaaabaaa=a >
bbaabbbaaabaaa -> a

# < a,b | bbaabbbaaababa=a >
bbaabbbaaababa -> a

# < a,b | bbaabbbaaabbaa=a >
bbaabbbaaabbaa -> a
bbaabbbaaaa -> abbbaaabbaa

# < a,b | bbaabbbaaabbba=a >
bbaabbbaaabbba -> a
bbaabbbaaaba -> aabbbaaabbba

# < a,b | bbaabbbaabaaaa=a >
bbaabbbaabaaaa -> a

# < a,b | bbaabbbaabaaba=a >
bbaabbbaabaaba -> a

# < a,b | bbaabbbaababaa=a >
bbaabbbaababaa -> a

# < a,b | bbaabbbaababba=a >
bbaabbbaababba -> a
bbaabbbaabaa -> aabbbaababba

# < a,b | bbaabbbaabbaaa=a >
bbaabbbaabbaaa -> a

# < a,b | bbaabbbaabbaba=a >
bbaabbbaabbaba -> a

# < a,b | bbaabbbaabbbaa=a >
bbaabbbaabbbaa -> a
bbaaba -> abbbaa

# < a,b | bbaabbbaabbbba=a >
bbaabbbaabbbba -> a
bbaabbbaabba -> aabbbaabbbba
bbaabbbaaa -> aabbbaabba

# < a,b | bbaabbbabaaaaa=a >
bbaabbbabaaaaa -> a

# < a,b | bbaabbbabaaaba=a >
bbaabbbabaaaba -> a

# < a,b | bbaabbbabaabaa=a >
bbaabbbabaabaa -> a

# < a,b | bbaabbbabaabba=a >
bbaabbbabaabba -> a
bbaabbbabaaa -> aabbbabaabba

# < a,b | bbaabbbababaaa=a >
bbaabbbababaaa -> a

# < a,b | bbaabbbabababa=a >
bbaabbbabababa -> a

# < a,b | bbaabbbababbaa=a >
bbaabbbababbaa -> a
bbaabbbabaa -> abbbababbaa

# < a,b | bbaabbbababbba=a >
bbaabbbababbba -> a
bbaabbbababa -> aabbbababbba

# < a,b | bbaabbbabbaaaa=a >
bbaabbbabbaaaa -> a

# < a,b | bbaabbbabbaaba=a >
bbaabbbabbaaba -> a

# < a,b | bbaabbbabbabaa=a >
bbaabbbabbabaa -> a

# < a,b | bbaabbbabbbaaa=a >
bbaabbbabbbaaa -> a

# < a,b | bbaabbbabbbaba=a >
bbaabbbabbbaba -> a

# < a,b | bbaabbbabbbbba=a >
bbaabbbabbbbba -> a
bbaabbbabbba -> aabbbabbbbba
bbaabbbaba -> aabbbabbba

# < a,b | bbaabbbbaaaaaa=a >
bbaabbbbaaaaaa -> a

# < a,b | bbaabbbbaaaaba=a >
bbaabbbbaaaaba -> a

# < a,b | bbaabbbbaaabaa=a >
bbaabbbbaaabaa -> a

# < a,b | bbaabbbbaaabba=a >
bbaabbbbaaabba -> a
bbaabbbbaaaa -> aabbbbaaabba

# < a,b | bbaabbbbaabaaa=a >
bbaabbbbaabaaa -> a

# < a,b | bbaabbbbaababa=a >
bbaabbbbaababa -> a

# < a,b | bbaabbbbaabbaa=a >
bbaabbbbaabbaa -> a
bbaabbbbaaa -> abbbbaabbaa

# < a,b | bbaabbbbaabbba=a >
bbaabbbbaabbba -> a
bbaabbbbaaba -> aabbbbaabbba

# < a,b | bbaabbbbabaaaa=a >
bbaabbbbabaaaa -> a

# < a,b | bbaabbbbabaaba=a >
bbaabbbbabaaba -> a

# < a,b | bbaabbbbababaa=a >
bbaabbbbababaa -> a

# < a,b | bbaabbbbababba=a >
bbaabbbbababba -> a
bbaabbbbabaa -> aabbbbababba

# < a,b | bbaabbbbabbaaa=a >
bbaabbbbabbaaa -> a

# < a,b | bbaabbbbabbaba=a >
bbaabbbbabbaba -> a

# < a,b | bbaabbbbabbbaa=a >
bbaabbbbabbbaa -> a
bbaabbbbaba -> abbbbabbbaa

# < a,b | bbaabbbbbaaaaa=a >
bbaabbbbbaaaaa -> a

# < a,b | bbaabbbbbaaaba=a >
bbaabbbbbaaaba -> a

# < a,b | bbaabbbbbaabaa=a >
bbaabbbbbaabaa -> a

# < a,b | bbaabbbbbaabba=a >
bbaabbbbbaabba -> a
bbaabbbbbaaa -> aabbbbbaabba

# < a,b | bbaabbbbbabaaa=a >
bbaabbbbbabaaa -> a

# < a,b | bbaabbbbbababa=a >
bbaabbbbbababa -> a

# < a,b | bbaabbbbbabbba=a >
bbaabbbbbabbba -> a
bbaabbbbbaba -> aabbbbbabbba

# < a,b | bbaabbbbbbaaaa=a >
bbaabbbbbbaaaa -> a

# < a,b | bbaabbbbbbaaba=a >
bbaabbbbbbaaba -> a

# < a,b | bbaabbbbbbabaa=a >
bbaabbbbbbabaa -> a

# < a,b | bbaabbbbbbbaaa=a >
bbaabbbbbbbaaa -> a

# < a,b | bbaabbbbbbbaba=a >
bbaabbbbbbbaba -> a

# < a,b | bbaabbbbbbbbba=a >
bbaabbbbbbbbba -> a
bbaabbbbbbba -> aabbbbbbbbba
bbaabbbbba -> aabbbbbbba
bbaabbba -> aabbbbba
bbaaba -> aabbba

# < a,b | bbabaaaaaaaaaa=a >
bbabaaaaaaaaaa -> a

# < a,b | bbabaaaaaaaaba=a >
bbabaaaaaaaaba -> a

# < a,b | bbabaaaaaaabaa=a >
bbabaaaaaaabaa -> a

# < a,b | bbabaaaaaaabba=a >
bbabaaaaaaabba -> a
bbabaaaaaaaa -> abaaaaaaabba

# < a,b | bbabaaaaaabaaa=a >
bbabaaaaaabaaa -> a

# < a,b | bbabaaaaaababa=a >
bbabaaaaaababa -> a

# < a,b | bbabaaaaaabbaa=a >
bbabaaaaaabbaa -> a

# < a,b | bbabaaaaaabbba=a >
bbabaaaaaabbba -> a
bbabaaaaaaba -> abaaaaaabbba

# < a,b | bbabaaaaabaaaa=a >
bbabaaaaabaaaa -> a

# < a,b | bbabaaaaabaaba=a >
bbabaaaaabaaba -> a

# < a,b | bbabaaaaababaa=a >
bbabaaaaababaa -> a

# < a,b | bbabaaaaababba=a >
bbabaaaaababba -> a
bbabaaaaabaa -> abaaaaababba

# < a,b | bbabaaaaabbaaa=a >
bbabaaaaabbaaa -> a

# < a,b | bbabaaaaabbaba=a >
bbabaaaaabbaba -> a
bbabaaaaaa -> aaaaabbaba

# < a,b | bbabaaaaabbbaa=a >
bbabaaaaabbbaa -> a

# < a,b | bbabaaaaabbbba=a >
bbabaaaaabbbba -> a
bbabaaaaabba -> abaaaaabbbba
bbabaaaaaa -> abaaaaabba

# < a,b | bbabaaaabaaaaa=a >
bbabaaaabaaaaa -> a

# < a,b | bbabaaaabaaaba=a >
bbabaaaabaaaba -> a

# < a,b | bbabaaaabaabaa=a >
bbabaaaabaabaa -> a

# < a,b | bbabaaaabaabba=a >
bbabaaaabaabba -> a
bbabaaaabaaa -> abaaaabaabba

# < a,b | bbabaaaababaaa=a >
bbabaaaababaaa -> a

# < a,b | bbabaaaabababa=a >
bbabaaaabababa -> a

# < a,b | bbabaaaababbaa=a >
bbabaaaababbaa -> a

# < a,b | bbabaaaababbba=a >
bbabaaaababbba -> a
bbabaaaababa -> abaaaababbba

# < a,b | bbabaaaabbaaaa=a >
bbabaaaabbaaaa -> a

# < a,b | bbabaaaabbaaba=a >
bbabaaaabbaaba -> a

# < a,b | bbabaaaabbabaa=a >
bbabaaaabbabaa -> a
bbabaaaaa -> aaabbabaa

# < a,b | bbabaaaabbabba=a >
bbabaaaabbabba -> a
bbabaaaabbaa -> abaaaabbabba

# < a,b | bbabaaaabbbaaa=a >
bbabaaaabbbaaa -> a

# < a,b | bbabaaaabbbaba=a >
bbabaaaabbbaba -> a
bbabaaaaba -> aaaabbbaba

# < a,b | bbabaaaabbbbaa=a >
bbabaaaabbbbaa -> a

# < a,b | bbabaaaabbbbba=a >
bbabaaaabbbbba -> a
bbabaaaabbba -> abaaaabbbbba
bbabaaaaba -> abaaaabbba

# < a,b | bbabaaabaaaaaa=a >
bbabaaabaaaaaa -> a

# < a,b | bbabaaabaaaaba=a >
bbabaaabaaaaba -> a

# < a,b | bbabaaabaaabaa=a >
bbabaaabaaabaa -> a

# < a,b | bbabaaabaaabba=a >
bbabaaabaaabba -> a
bbabaaabaaaa -> abaaabaaabba

# < a,b | bbabaaabaabaaa=a >
bbabaaabaabaaa -> a

# < a,b | bbabaaabaababa=a >
bbabaaabaababa -> a

# < a,b | bbabaaabaabbaa=a >
bbabaaabaabbaa -> a

# < a,b | bbabaaabaabbba=a >
bbabaaabaabbba -> a
bbabaaabaaba -> abaaabaabbba

# < a,b | bbabaaababaaaa=a >
bbabaaababaaaa -> a

# < a,b | bbabaaababaaba=a >
bbabaaababaaba -> a

# < a,b | bbabaaabababaa=a >
bbabaaabababaa -> a

# < a,b | bbabaaabababba=a >
bbabaaabababba -> a
bbabaaababaa -> abaaabababba

# < a,b | bbabaaababbaaa=a >
bbabaaababbaaa -> a

# < a,b | bbabaaababbaba=a >
bbabaaababbaba -> a
bbabaaabaa -> aaababbaba

# < a,b | bbabaaababbbaa=a >
bbabaaababbbaa -> a

# < a,b | bbabaaababbbba=a >
bbabaaababbbba -> a
bbabaaababba -> abaaababbbba
bbabaaabaa -> abaaababba

# < a,b | bbabaaabbaaaaa=a >
bbabaaabbaaaaa -> a

# < a,b | bbabaaabbaaaba=a >
bbabaaabbaaaba -> a

# < a,b | bbabaaabbaabaa=a >
bbabaaabbaabaa -> a

# < a,b | bbabaaabbaabba=a >
bbabaaabbaabba -> a
bbabaaabbaaa -> abaaabbaabba

# < a,b | bbabaaabbabaaa=a >
bbabaaabbabaaa -> a
bbabaaaa -> abbabaaa

# < a,b | bbabaaabbababa=a >
bbabaaabbababa -> a

# < a,b | bbabaaabbabbaa=a >
bbabaaabbabbaa -> a

# < a,b | bbabaaabbbaaaa=a >
bbabaaabbbaaaa -> a

# < a,b | bbabaaabbbaaba=a >
bbabaaabbbaaba -> a

# < a,b | bbabaaabbbabaa=a >
bbabaaabbbabaa -> a
bbabaaaba -> aabbbabaa

# < a,b | bbabaaabbbabba=a >
bbabaaabbbabba -> a
bbabaaabbbaa -> abaaabbbabba

# < a,b | bbabaaabbbbaaa=a >
bbabaaabbbbaaa -> a

# < a,b | bbabaaabbbbbaa=a >
bbabaaabbbbbaa -> a

# < a,b | bbabaaabbbbbba=a >
bbabaaabbbbbba -> a
bbabaaabbbba -> abaaabbbbbba
bbabaaabba -> abaaabbbba
bbabaaaa -> abaaabba

# < a,b | bbabaabaaaaaaa=a >
bbabaabaaaaaaa -> a

# < a,b | bbabaabaaaaaba=a >
bbabaabaaaaaba -> a

# < a,b | bbabaabaaaabaa=a >
bbabaabaaaabaa -> a

# < a,b | bbabaabaaaabba=a >
bbabaabaaaabba -> a
bbabaabaaaaa -> abaabaaaabba

# < a,b | bbabaabaaabaaa=a >
bbabaabaaabaaa -> a

# < a,b | bbabaabaaababa=a >
bbabaabaaababa -> a

# < a,b | bbabaabaaabbaa=a >
bbabaabaaabbaa -> a

# < a,b | bbabaabaaabbba=a >
bbabaabaaabbba -> a
bbabaabaaaba -> abaabaaabbba

# < a,b | bbabaabaabaaaa=a >
bbabaabaabaaaa -> a

# < a,b | bbabaabaabaaba=a >
bbabaabaabaaba -> a

# < a,b | bbabaabaababaa=a >
bbabaabaababaa -> a

# < a,b | bbabaabaababba=a >
bbabaabaababba -> a
bbabaabaabaa -> abaabaababba

# < a,b | bbabaabaabbaaa=a >
bbabaabaabbaaa -> a

# < a,b | bbabaabaabbaba=a >
bbabaabaabbaba -> a
bbabaabaaa -> aabaabbaba

# < a,b | bbabaabaabbbaa=a >
bbabaabaabbbaa -> a

# < a,b | bbabaabaabbbba=a >
bbabaabaabbbba -> a
bbabaabaabba -> abaabaabbbba
bbabaabaaa -> abaabaabba

# < a,b | bbabaababaaaaa=a >
bbabaababaaaaa -> a

# < a,b | bbabaababaaaba=a >
bbabaababaaaba -> a

# < a,b | bbabaababaabaa=a >
bbabaababaabaa -> a

# < a,b | bbabaababaabba=a >
bbabaababaabba -> a
bbabaababaaa -> abaababaabba

# < a,b | bbabaabababaaa=a >
bbabaabababaaa -> a

# < a,b | bbabaababababa=a >
bbabaababababa -> a

# < a,b | bbabaabababbaa=a >
bbabaabababbaa -> a

# < a,b | bbabaabababbba=a >
bbabaabababbba -> a
bbabaabababa -> abaabababbba

# < a,b | bbabaababbaaaa=a >
bbabaababbaaaa -> a

# < a,b | bbabaababbaaba=a >
bbabaababbaaba -> a

# < a,b | bbabaababbabaa=a >
bbabaababbabaa -> a
bbabaabaa -> ababbabaa

# < a,b | bbabaababbabba=a >
bbabaababbabba -> a
bbabaababbaa -> abaababbabba

# < a,b | bbabaababbbaaa=a >
bbabaababbbaaa -> a

# < a,b | bbabaababbbaba=a >
bbabaababbbaba -> a
bbabaababa -> aababbbaba

# < a,b | bbabaababbbbaa=a >
bbabaababbbbaa -> a

# < a,b | bbabaababbbbba=a >
bbabaababbbbba -> a
bbabaababbba -> abaababbbbba
bbabaababa -> abaababbba

# < a,b | bbabaabbaaaaaa=a >
bbabaabbaaaaaa -> a

# < a,b | bbabaabbaaaaba=a >
bbabaabbaaaaba -> a

# < a,b | bbabaabbaaabaa=a >
bbabaabbaaabaa -> a

# < a,b | bbabaabbaaabba=a >
bbabaabbaaabba -> a
bbabaabbaaaa -> abaabbaaabba

# < a,b | bbabaabbaabaaa=a >
bbabaabbaabaaa -> a

# < a,b | bbabaabbaababa=a >
bbabaabbaababa -> a

# < a,b | bbabaabbaabbaa=a >
bbabaabbaabbaa -> a

# < a,b | bbabaabbaabbba=a >
bbabaabbaabbba -> a
bbabaabbaaba -> abaabbaabbba

# < a,b | bbabaabbabaaaa=a >
bbabaabbabaaaa -> a

# < a,b | bbabaabbabaaba=a >
bbabaabbabaaba -> a

# < a,b | bbabaabbababaa=a >
bbabaabbababaa -> a

# < a,b | bbabaabbabbaaa=a >
bbabaabbabbaaa -> a

# < a,b | bbabaabbabbaba=a >
bbabaabbabbaba -> a
bbabaabbaa -> aabbabbaba

# < a,b | bbabaabbabbbaa=a >
bbabaabbabbbaa -> a

# < a,b | bbabaabbabbbba=a >
bbabaabbabbbba -> a
bbabaabbabba -> abaabbabbbba
bbabaabbaa -> abaabbabba

# < a,b | bbabaabbbaaaaa=a >
bbabaabbbaaaaa -> a

# < a,b | bbabaabbbaaaba=a >
bbabaabbbaaaba -> a

# < a,b | bbabaabbbaabaa=a >
bbabaabbbaabaa -> a

# < a,b | bbabaabbbaabba=a >
bbabaabbbaabba -> a
bbabaabbbaaa -> abaabbbaabba

# < a,b | bbabaabbbabaaa=a >
bbabaabbbabaaa -> a

# < a,b | bbabaabbbababa=a >
bbabaabbbababa -> a

# < a,b | bbabaabbbabbaa=a >
bbabaabbbabbaa -> a

# < a,b | bbabaabbbbaaaa=a >
bbabaabbbbaaaa -> a

# < a,b | bbabaabbbbaaba=a >
bbabaabbbbaaba -> a

# < a,b | bbabaabbbbabba=a >
bbabaabbbbabba -> a
bbabaabbbbaa -> abaabbbbabba

# < a,b | bbabaabbbbbaaa=a >
bbabaabbbbbaaa -> a

# < a,b | bbabaabbbbbbaa=a >
bbabaabbbbbbaa -> a

# < a,b | bbabaabbbbbbba=a >
bbabaabbbbbbba -> a
bbabaabbbbba -> abaabbbbbbba
bbabaabbba -> abaabbbbba
bbabaaba -> abaabbba

# < a,b | bbababaaaaaaaa=a >
bbababaaaaaaaa -> a

# < a,b | bbababaaaaaaba=a >
bbababaaaaaaba -> a

# < a,b | bbababaaaaabaa=a >
bbababaaaaabaa -> a

# < a,b | bbababaaaaabba=a >
bbababaaaaabba -> a
bbababaaaaaa -> ababaaaaabba

# < a,b | bbababaaaabaaa=a >
bbababaaaabaaa -> a

# < a,b | bbababaaaababa=a >
bbababaaaababa -> a

# < a,b | bbababaaaabbaa=a >
bbababaaaabbaa -> a

# < a,b | bbababaaaabbba=a >
bbababaaaabbba -> a
bbababaaaaba -> ababaaaabbba

# < a,b | bbababaaabaaaa=a >
bbababaaabaaaa -> a

# < a,b | bbababaaabaaba=a >
bbababaaabaaba -> a

# < a,b | bbababaaababaa=a >
bbababaaababaa -> a

# < a,b | bbababaaababba=a >
bbababaaababba -> a
bbababaaabaa -> ababaaababba

# < a,b | bbababaaabbaaa=a >
bbababaaabbaaa -> a

# < a,b | bbababaaabbaba=a >
bbababaaabbaba -> a
bbababaaaa -> abaaabbaba

# < a,b | bbababaaabbbaa=a >
bbababaaabbbaa -> a

# < a,b | bbababaaabbbba=a >
bbababaaabbbba -> a
bbababaaabba -> ababaaabbbba
bbababaaaa -> ababaaabba

# < a,b | bbababaabaaaaa=a >
bbababaabaaaaa -> a

# < a,b | bbababaabaaaba=a >
bbababaabaaaba -> a

# < a,b | bbababaabaabaa=a >
bbababaabaabaa -> a

# < a,b | bbababaabaabba=a >
bbababaabaabba -> a
bbababaabaaa -> ababaabaabba

# < a,b | bbababaababaaa=a >
bbababaababaaa -> a

# < a,b | bbababaabababa=a >
bbababaabababa -> a

# < a,b | bbababaababbaa=a >
bbababaababbaa -> a

# < a,b | bbababaababbba=a >
bbababaababbba -> a
bbababaababa -> ababaababbba

# < a,b | bbababaabbaaaa=a >
bbababaabbaaaa -> a

# < a,b | bbababaabbaaba=a >
bbababaabbaaba -> a

# < a,b | bbababaabbabaa=a >
bbababaabbabaa -> a

# < a,b | bbababaabbabba=a >
bbababaabbabba -> a
bbababaabbaa -> ababaabbabba

# < a,b | bbababaabbbaaa=a >
bbababaabbbaaa -> a

# < a,b | bbababaabbbaba=a >
bbababaabbbaba -> a
bbababaaba -> abaabbbaba

# < a,b | bbababaabbbbaa=a >
bbababaabbbbaa -> a

# < a,b | bbababaabbbbba=a >
bbababaabbbbba -> a
bbababaabbba -> ababaabbbbba
bbababaaba -> ababaabbba

# < a,b | bbabababaaaaaa=a >
bbabababaaaaaa -> a

# < a,b | bbabababaaaaba=a >
bbabababaaaaba -> a

# < a,b | bbabababaaabaa=a >
bbabababaaabaa -> a

# < a,b | bbabababaaabba=a >
bbabababaaabba -> a
bbabababaaaa -> abababaaabba

# < a,b | bbabababaabaaa=a >
bbabababaabaaa -> a

# < a,b | bbabababaababa=a >
bbabababaababa -> a

# < a,b | bbabababaabbaa=a >
bbabababaabbaa -> a

# < a,b | bbabababaabbba=a >
bbabababaabbba -> a
bbabababaaba -> abababaabbba

# < a,b | bbababababaaaa=a >
bbababababaaaa -> a

# < a,b | bbababababaaba=a >
bbababababaaba -> a

# < a,b | bbabababababaa=a >
bbabababababaa -> a

# < a,b | bbabababababba=a >
bbabababababba -> a
bbababababaa -> abababababba

# < a,b | bbababababbaaa=a >
bbababababbaaa -> a

# < a,b | bbababababbaba=a >
bbababababbaba -> a
bbabababaa -> abababbaba

# < a,b | bbababababbbaa=a >
bbababababbbaa -> a

# < a,b | bbababababbbba=a >
bbababababbbba -> a
bbababababba -> ababababbbba
bbabababaa -> ababababba

# < a,b | bbabababbaaaaa=a >
bbabababbaaaaa -> a

# < a,b | bbabababbaaaba=a >
bbabababbaaaba -> a

# < a,b | bbabababbaabaa=a >
bbabababbaabaa -> a

# < a,b | bbabababbaabba=a >
bbabababbaabba -> a
bbabababbaaa -> abababbaabba

# < a,b | bbabababbabaaa=a >
bbabababbabaaa -> a

# < a,b | bbabababbababa=a >
bbabababbababa -> a
bbababaa -> abbababa

# < a,b | bbabababbabbaa=a >
bbabababbabbaa -> a

# < a,b | bbabababbbaaaa=a >
bbabababbbaaaa -> a

# < a,b | bbabababbbaaba=a >
bbabababbbaaba -> a

# < a,b | bbabababbbabaa=a >
bbabababbbabaa -> a

# < a,b | bbabababbbabba=a >
bbabababbbabba -> a
bbabababbbaa -> abababbbabba

# < a,b | bbabababbbbaaa=a >
bbabababbbbaaa -> a

# < a,b | bbabababbbbbaa=a >
bbabababbbbbaa -> a

# < a,b | bbabababbbbbba=a >
bbabababbbbbba -> a
bbabababbbba -> abababbbbbba
bbabababba -> abababbbba
bbababaa -> abababba

# < a,b | bbababbaaaaaaa=a >
bbababbaaaaaaa -> a

# < a,b | bbababbaaaaaba=a >
bbababbaaaaaba -> a

# < a,b | bbababbaaaabaa=a >
bbababbaaaabaa -> a

# < a,b | bbababbaaaabba=a >
bbababbaaaabba -> a
bbababbaaaaa -> ababbaaaabba

# < a,b | bbababbaaabaaa=a >
bbababbaaabaaa -> a

# < a,b | bbababbaaababa=a >
bbababbaaababa -> a

# < a,b | bbababbaaabbaa=a >
bbababbaaabbaa -> a

# < a,b | bbababbaaabbba=a >
bbababbaaabbba -> a
bbababbaaaba -> ababbaaabbba

# < a,b | bbababbaabaaaa=a >
bbababbaabaaaa -> a

# < a,b | bbababbaabaaba=a >
bbababbaabaaba -> a

# < a,b | bbababbaababaa=a >
bbababbaababaa -> a

# < a,b | bbababbaababba=a >
bbababbaababba -> a
bbababbaabaa -> ababbaababba

# < a,b | bbababbaabbaaa=a >
bbababbaabbaaa -> a

# < a,b | bbababbaabbaba=a >
bbababbaabbaba -> a
bbababbaaa -> abbaabbaba

# < a,b | bbababbaabbbaa=a >
bbababbaabbbaa -> a

# < a,b | bbababbaabbbba=a >
bbababbaabbbba -> a
bbababbaabba -> ababbaabbbba
bbababbaaa -> ababbaabba

# < a,b | bbababbabaaaaa=a >
bbababbabaaaaa -> a

# < a,b | bbababbabaaaba=a >
bbababbabaaaba -> a

# < a,b | bbababbabaabaa=a >
bbababbabaabaa -> a

# < a,b | bbababbabaabba=a >
bbababbabaabba -> a
bbababbabaaa -> ababbabaabba

# < a,b | bbababbababaaa=a >
bbababbababaaa -> a

# < a,b | bbababbabababa=a >
bbababbabababa -> a

# < a,b | bbababbababbaa=a >
bbababbababbaa -> a

# < a,b | bbababbababbba=a >
bbababbababbba -> a
bbababbababa -> ababbababbba

# < a,b | bbababbabbaaaa=a >
bbababbabbaaaa -> a

# < a,b | bbababbabbaaba=a >
bbababbabbaaba -> a

# < a,b | bbababbabbabaa=a >
bbababbabbabaa -> a

# < a,b | bbababbabbabba=a >
bbababbabbabba -> a
bbababbabbaa -> ababbabbabba

# < a,b | bbababbabbbaaa=a >
bbababbabbbaaa -> a

# < a,b | bbababbabbbaba=a >
bbababbabbbaba -> a
bbababbaba -> abbabbbaba
bbabaa -> abbaba

# < a,b | bbababbabbbbaa=a >
bbababbabbbbaa -> a

# < a,b | bbababbbaaaaaa=a >
bbababbbaaaaaa -> a

# < a,b | bbababbbaaaaba=a >
bbababbbaaaaba -> a

# < a,b | bbababbbaaabaa=a >
bbababbbaaabaa -> a

# < a,b | bbababbbaaabba=a >
bbababbbaaabba -> a
bbababbbaaaa -> ababbbaaabba

# < a,b | bbababbbaabaaa=a >
bbababbbaabaaa -> a

# < a,b | bbababbbaababa=a >
bbababbbaababa -> a

# < a,b | bbababbbaabbaa=a >
bbababbbaabbaa -> a

# < a,b | bbababbbaabbba=a >
bbababbbaabbba -> a
bbababbbaaba -> ababbbaabbba

# < a,b | bbababbbabaaaa=a >
bbababbbabaaaa -> a

# < a,b | bbababbbabaaba=a >
bbababbbabaaba -> a

# < a,b | bbababbbababaa=a >
bbababbbababaa -> a

# < a,b | bbababbbababba=a >
bbababbbababba -> a
bbababbbabaa -> ababbbababba

# < a,b | bbababbbabbaaa=a >
bbababbbabbaaa -> a

# < a,b | bbababbbabbaba=a >
bbababbbabbaba -> a
bbababbbaa -> abbbabbaba

# < a,b | bbababbbabbbaa=a >
bbababbbabbbaa -> a

# < a,b | bbababbbabbbba=a >
bbababbbabbbba -> a
bbababbbabba -> ababbbabbbba
bbababbbaa -> ababbbabba

# < a,b | bbababbbbaaaaa=a >
bbababbbbaaaaa -> a

# < a,b | bbababbbbaaaba=a >
bbababbbbaaaba -> a

# < a,b | bbababbbbaabaa=a >
bbababbbbaabaa -> a

# < a,b | bbababbbbaabba=a >
bbababbbbaabba -> a
bbababbbbaaa -> ababbbbaabba

# < a,b | bbababbbbabaaa=a >
bbababbbbabaaa -> a

# < a,b | bbababbbbababa=a >
bbababbbbababa -> a

# < a,b | bbababbbbabbaa=a >
bbababbbbabbaa -> a

# < a,b | bbababbbbbaaaa=a >
bbababbbbbaaaa -> a

# < a,b | bbababbbbbaaba=a >
bbababbbbbaaba -> a

# < a,b | bbababbbbbabaa=a >
bbababbbbbabaa -> a

# < a,b | bbababbbbbabba=a >
bbababbbbbabba -> a
bbababbbbbaa -> ababbbbbabba

# < a,b | bbababbbbbbaaa=a >
bbababbbbbbaaa -> a

# < a,b | bbababbbbbbbaa=a >
bbababbbbbbbaa -> a

# < a,b | bbababbbbbbbba=a >
bbababbbbbbbba -> a
bbababbbbbba -> ababbbbbbbba
bbababbbba -> ababbbbbba
bbababba -> ababbbba
bbabaa -> ababba

# < a,b | bbabbaaaaaaaaa=a >
bbabbaaaaaaaaa -> a

# < a,b | bbabbaaaaaaaba=a >
bbabbaaaaaaaba -> a

# < a,b | bbabbaaaaaabaa=a >
bbabbaaaaaabaa -> a

# < a,b | bbabbaaaaaabba=a >
bbabbaaaaaabba -> a
bbabbaaaaaaa -> abbaaaaaabba

# < a,b | bbabbaaaaabaaa=a >
bbabbaaaaabaaa -> a

# < a,b | bbabbaaaaababa=a >
bbabbaaaaababa -> a

# < a,b | bbabbaaaaabbaa=a >
bbabbaaaaabbaa -> a

# < a,b | bbabbaaaaabbba=a >
bbabbaaaaabbba -> a
bbabbaaaaaba -> abbaaaaabbba

# < a,b | bbabbaaaabaaaa=a >
bbabbaaaabaaaa -> a

# < a,b | bbabbaaaabaaba=a >
bbabbaaaabaaba -> a

# < a,b | bbabbaaaababaa=a >
bbabbaaaababaa -> a

# < a,b | bbabbaaaababba=a >
bbabbaaaababba -> a
bbabbaaaabaa -> abbaaaababba

# < a,b | bbabbaaaabbaaa=a >
bbabbaaaabbaaa -> a

# < a,b | bbabbaaaabbaba=a >
bbabbaaaabbaba -> a

# < a,b | bbabbaaaabbbaa=a >
bbabbaaaabbbaa -> a

# < a,b | bbabbaaaabbbba=a >
bbabbaaaabbbba -> a
bbabbaaaabba -> abbaaaabbbba
bbabbaaaaa -> abbaaaabba

# < a,b | bbabbaaabaaaaa=a >
bbabbaaabaaaaa -> a

# < a,b | bbabbaaabaaaba=a >
bbabbaaabaaaba -> a

# < a,b | bbabbaaabaabaa=a >
bbabbaaabaabaa -> a

# < a,b | bbabbaaabaabba=a >
bbabbaaabaabba -> a
bbabbaaabaaa -> abbaaabaabba

# < a,b | bbabbaaababaaa=a >
bbabbaaababaaa -> a

# < a,b | bbabbaaabababa=a >
bbabbaaabababa -> a

# < a,b | bbabbaaababbaa=a >
bbabbaaababbaa -> a

# < a,b | bbabbaaababbba=a >
bbabbaaababbba -> a
bbabbaaababa -> abbaaababbba

# < a,b | bbabbaaabbaaaa=a >
bbabbaaabbaaaa -> a

# < a,b | bbabbaaabbaaba=a >
bbabbaaabbaaba -> a

# < a,b | bbabbaaabbabaa=a >
bbabbaaabbabaa -> a

# < a,b | bbabbaaabbabba=a >
bbabbaaabbabba -> a
bbabbaaabbaa -> abbaaabbabba
bbabbaaaa -> aaabbabba

# < a,b | bbabbaaabbbaaa=a >
bbabbaaabbbaaa -> a

# < a,b | bbabbaaabbbaba=a >
bbabbaaabbbaba -> a

# < a,b | bbabbaaabbbbaa=a >
bbabbaaabbbbaa -> a

# < a,b | bbabbaaabbbbba=a >
bbabbaaabbbbba -> a
bbabbaaabbba -> abbaaabbbbba
bbabbaaaba -> abbaaabbba

# < a,b | bbabbaabaaaaaa=a >
bbabbaabaaaaaa -> a

# < a,b | bbabbaabaaaaba=a >
bbabbaabaaaaba -> a

# < a,b | bbabbaabaaabaa=a >
bbabbaabaaabaa -> a

# < a,b | bbabbaabaaabba=a >
bbabbaabaaabba -> a
bbabbaabaaaa -> abbaabaaabba

# < a,b | bbabbaabaabaaa=a >
bbabbaabaabaaa -> a

# < a,b | bbabbaabaababa=a >
bbabbaabaababa -> a

# < a,b | bbabbaabaabbaa=a >
bbabbaabaabbaa -> a

# < a,b | bbabbaabaabbba=a >
bbabbaabaabbba -> a
bbabbaabaaba -> abbaabaabbba

# < a,b | bbabbaababaaaa=a >
bbabbaababaaaa -> a

# < a,b | bbabbaababaaba=a >
bbabbaababaaba -> a

# < a,b | bbabbaabababaa=a >
bbabbaabababaa -> a

# < a,b | bbabbaabababba=a >
bbabbaabababba -> a
bbabbaababaa -> abbaabababba

# < a,b | bbabbaababbaaa=a >
bbabbaababbaaa -> a

# < a,b | bbabbaababbaba=a >
bbabbaababbaba -> a

# < a,b | bbabbaababbbaa=a >
bbabbaababbbaa -> a

# < a,b | bbabbaababbbba=a >
bbabbaababbbba -> a
bbabbaababba -> abbaababbbba
bbabbaabaa -> abbaababba

# < a,b | bbabbaabbaaaaa=a >
bbabbaabbaaaaa -> a

# < a,b | bbabbaabbaaaba=a >
bbabbaabbaaaba -> a

# < a,b | bbabbaabbaabaa=a >
bbabbaabbaabaa -> a

# < a,b | bbabbaabbaabba=a >
bbabbaabbaabba -> a
bbabbaabbaaa -> abbaabbaabba

# < a,b | bbabbaabbabaaa=a >
bbabbaabbabaaa -> a

# < a,b | bbabbaabbababa=a >
bbabbaabbababa -> a

# < a,b | bbabbaabbabbaa=a >
bbabbaabbabbaa -> a
bbabbaaa -> abbabbaa

# < a,b | bbabbaabbabbba=a >
bbabbaabbabbba -> a
bbabbaabbaba -> abbaabbabbba

# < a,b | bbabbaabbbaaaa=a >
bbabbaabbbaaaa -> a

# < a,b | bbabbaabbbaaba=a >
bbabbaabbbaaba -> a

# < a,b | bbabbaabbbabaa=a >
bbabbaabbbabaa -> a

# < a,b | bbabbaabbbabba=a >
bbabbaabbbabba -> a
bbabbaabbbaa -> abbaabbbabba
bbabbaaba -> aabbbabba

# < a,b | bbabbaabbbbaaa=a >
bbabbaabbbbaaa -> a

# < a,b | bbabbaabbbbaba=a >
bbabbaabbbbaba -> a

# < a,b | bbabbaabbbbbaa=a >
bbabbaabbbbbaa -> a

# < a,b | bbabbaabbbbbba=a >
bbabbaabbbbbba -> a
bbabbaabbbba -> abbaabbbbbba
bbabbaabba -> abbaabbbba
bbabbaaa -> abbaabba

# < a,b | bbabbabaaaaaaa=a >
bbabbabaaaaaaa -> a

# < a,b | bbabbabaaaaaba=a >
bbabbabaaaaaba -> a

# < a,b | bbabbabaaaabaa=a >
bbabbabaaaabaa -> a

# < a,b | bbabbabaaaabba=a >
bbabbabaaaabba -> a
bbabbabaaaaa -> abbabaaaabba

# < a,b | bbabbabaaabaaa=a >
bbabbabaaabaaa -> a

# < a,b | bbabbabaaababa=a >
bbabbabaaababa -> a

# < a,b | bbabbabaaabbaa=a >
bbabbabaaabbaa -> a

# < a,b | bbabbabaaabbba=a >
bbabbabaaabbba -> a
bbabbabaaaba -> abbabaaabbba

# < a,b | bbabbabaabaaaa=a >
bbabbabaabaaaa -> a

# < a,b | bbabbabaabaaba=a >
bbabbabaabaaba -> a

# < a,b | bbabbabaababaa=a >
bbabbabaababaa -> a

# < a,b | bbabbabaababba=a >
bbabbabaababba -> a
bbabbabaabaa -> abbabaababba

# < a,b | bbabbabaabbaaa=a >
bbabbabaabbaaa -> a

# < a,b | bbabbabaabbaba=a >
bbabbabaabbaba -> a

# < a,b | bbabbabaabbbaa=a >
bbabbabaabbbaa -> a

# < a,b | bbabbabaabbbba=a >
bbabbabaabbbba -> a
bbabbabaabba -> abbabaabbbba
bbabbabaaa -> abbabaabba

# < a,b | bbabbababaaaaa=a >
bbabbababaaaaa -> a

# < a,b | bbabbababaaaba=a >
bbabbababaaaba -> a

# < a,b | bbabbababaabaa=a >
bbabbababaabaa -> a

# < a,b | bbabbababaabba=a >
bbabbababaabba -> a
bbabbababaaa -> abbababaabba

# < a,b | bbabbabababaaa=a >
bbabbabababaaa -> a

# < a,b | bbabbababababa=a >
bbabbababababa -> a

# < a,b | bbabbabababbaa=a >
bbabbabababbaa -> a

# < a,b | bbabbabababbba=a >
bbabbabababbba -> a
bbabbabababa -> abbabababbba

# < a,b | bbabbababbaaaa=a >
bbabbababbaaaa -> a

# < a,b | bbabbababbaaba=a >
bbabbababbaaba -> a

# < a,b | bbabbababbabaa=a >
bbabbababbabaa -> a

# < a,b | bbabbababbabba=a >
bbabbababbabba -> a
bbabbababbaa -> abbababbabba
bbabbabaa -> ababbabba

# < a,b | bbabbababbbaaa=a >
bbabbababbbaaa -> a

# < a,b | bbabbababbbaba=a >
bbabbababbbaba -> a

# < a,b | bbabbababbbbaa=a >
bbabbababbbbaa -> a

# < a,b | bbabbababbbbba=a >
bbabbababbbbba -> a
bbabbababbba -> abbababbbbba
bbabbababa -> abbababbba

# < a,b | bbabbabbaaaaaa=a >
bbabbabbaaaaaa -> a

# < a,b | bbabbabbaaaaba=a >
bbabbabbaaaaba -> a

# < a,b | bbabbabbaaabaa=a >
bbabbabbaaabaa -> a

# < a,b | bbabbabbaaabba=a >
bbabbabbaaabba -> a
bbabbabbaaaa -> abbabbaaabba

# < a,b | bbabbabbaabaaa=a >
bbabbabbaabaaa -> a

# < a,b | bbabbabbaababa=a >
bbabbabbaababa -> a

# < a,b | bbabbabbaabbaa=a >
bbabbabbaabbaa -> a

# < a,b | bbabbabbaabbba=a >
bbabbabbaabbba -> a
bbabbabbaaba -> abbabbaabbba

# < a,b | bbabbabbabaaaa=a >
bbabbabbabaaaa -> a

# < a,b | bbabbabbabaaba=a >
bbabbabbabaaba -> a

# < a,b | bbabbabbababaa=a >
bbabbabbababaa -> a

# < a,b | bbabbabbababba=a >
bbabbabbababba -> a
bbabbabbabaa -> abbabbababba

# < a,b | bbabbabbabbaaa=a >
bbabbabbabbaaa -> a

# < a,b | bbabbabbabbaba=a >
bbabbabbabbaba -> a

# < a,b | bbabbabbabbbaa=a >
bbabbabbabbbaa -> a

# < a,b | bbabbabbbaaaaa=a >
bbabbabbbaaaaa -> a

# < a,b | bbabbabbbaaaba=a >
bbabbabbbaaaba -> a

# < a,b | bbabbabbbaabaa=a >
bbabbabbbaabaa -> a

# < a,b | bbabbabbbaabba=a >
bbabbabbbaabba -> a
bbabbabbbaaa -> abbabbbaabba

# < a,b | bbabbabbbabaaa=a >
bbabbabbbabaaa -> a

# < a,b | bbabbabbbababa=a >
bbabbabbbababa -> a

# < a,b | bbabbabbbabbaa=a >
bbabbabbbabbaa -> a

# < a,b | bbabbabbbabbba=a >
bbabbabbbabbba -> a
bbabbabbbaba -> abbabbbabbba

# < a,b | bbabbabbbbaaaa=a >
bbabbabbbbaaaa -> a

# < a,b | bbabbabbbbaaba=a >
bbabbabbbbaaba -> a

# < a,b | bbabbabbbbabaa=a >
bbabbabbbbabaa -> a

# < a,b | bbabbabbbbabba=a >
bbabbabbbbabba -> a
bbabbabba -> abbbbabba
bbaa -> abba

# < a,b | bbabbabbbbbaaa=a >
bbabbabbbbbaaa -> a

# < a,b | bbabbabbbbbaba=a >
bbabbabbbbbaba -> a

# < a,b | bbabbabbbbbbaa=a >
bbabbabbbbbbaa -> a

# < a,b | bbabbabbbbbbba=a >
bbabbabbbbbbba -> a
bbabbabbbbba -> abbabbbbbbba
bbabbabbba -> abbabbbbba
bbabbaba -> abbabbba

# < a,b | bbabbbaaaaaaaa=a >
bbabbbaaaaaaaa -> a

# < a,b | bbabbbaaaaaaba=a >
bbabbbaaaaaaba -> a

# < a,b | bbabbbaaaaabaa=a >
bbabbbaaaaabaa -> a

# < a,b | bbabbbaaaaabba=a >
bbabbbaaaaabba -> a
bbabbbaaaaaa -> abbbaaaaabba

# < a,b | bbabbbaaaabaaa=a >
bbabbbaaaabaaa -> a

# < a,b | bbabbbaaaababa=a >
bbabbbaaaababa -> a

# < a,b | bbabbbaaaabbaa=a >
bbabbbaaaabbaa -> a

# < a,b | bbabbbaaaabbba=a >
bbabbbaaaabbba -> a
bbabbbaaaaba -> abbbaaaabbba

# < a,b | bbabbbaaabaaaa=a >
bbabbbaaabaaaa -> a

# < a,b | bbabbbaaabaaba=a >
bbabbbaaabaaba -> a

# < a,b | bbabbbaaababaa=a >
bbabbbaaababaa -> a

# < a,b | bbabbbaaababba=a >
bbabbbaaababba -> a
bbabbbaaabaa -> abbbaaababba

# < a,b | bbabbbaaabbaaa=a >
bbabbbaaabbaaa -> a

# < a,b | bbabbbaaabbaba=a >
bbabbbaaabbaba -> a

# < a,b | bbabbbaaabbbaa=a >
bbabbbaaabbbaa -> a

# < a,b | bbabbbaaabbbba=a >
bbabbbaaabbbba -> a
bbabbbaaabba -> abbbaaabbbba
bbabbbaaaa -> abbbaaabba

# < a,b | bbabbbaabaaaaa=a >
bbabbbaabaaaaa -> a

# < a,b | bbabbbaabaaaba=a >
bbabbbaabaaaba -> a

# < a,b | bbabbbaabaabaa=a >
bbabbbaabaabaa -> a

# < a,b | bbabbbaabaabba=a >
bbabbbaabaabba -> a
bbabbbaabaaa -> abbbaabaabba

# < a,b | bbabbbaababaaa=a >
bbabbbaababaaa -> a

# < a,b | bbabbbaabababa=a >
bbabbbaabababa -> a

# < a,b | bbabbbaababbaa=a >
bbabbbaababbaa -> a

# < a,b | bbabbbaababbba=a >
bbabbbaababbba -> a
bbabbbaababa -> abbbaababbba

# < a,b | bbabbbaabbaaaa=a >
bbabbbaabbaaaa -> a

# < a,b | bbabbbaabbaaba=a >
bbabbbaabbaaba -> a

# < a,b | bbabbbaabbabaa=a >
bbabbbaabbabaa -> a

# < a,b | bbabbbaabbabba=a >
bbabbbaabbabba -> a
bbabbbaabbaa -> abbbaabbabba

# < a,b | bbabbbaabbbaaa=a >
bbabbbaabbbaaa -> a

# < a,b | bbabbbaabbbaba=a >
bbabbbaabbbaba -> a

# < a,b | bbabbbaabbbbaa=a >
bbabbbaabbbbaa -> a

# < a,b | bbabbbaabbbbba=a >
bbabbbaabbbbba -> a
bbabbbaabbba -> abbbaabbbbba
bbabbbaaba -> abbbaabbba

# < a,b | bbabbbabaaaaaa=a >
bbabbbabaaaaaa -> a

# < a,b | bbabbbabaaaaba=a >
bbabbbabaaaaba -> a

# < a,b | bbabbbabaaabaa=a >
bbabbbabaaabaa -> a

# < a,b | bbabbbabaaabba=a >
bbabbbabaaabba -> a
bbabbbabaaaa -> abbbabaaabba

# < a,b | bbabbbabaabaaa=a >
bbabbbabaabaaa -> a

# < a,b | bbabbbabaababa=a >
bbabbbabaababa -> a

# < a,b | bbabbbabaabbaa=a >
bbabbbabaabbaa -> a

# < a,b | bbabbbabaabbba=a >
bbabbbabaabbba -> a
bbabbbabaaba -> abbbabaabbba

# < a,b | bbabbbababaaaa=a >
bbabbbababaaaa -> a

# < a,b | bbabbbababaaba=a >
bbabbbababaaba -> a

# < a,b | bbabbbabababaa=a >
bbabbbabababaa -> a

# < a,b | bbabbbabababba=a >
bbabbbabababba -> a
bbabbbababaa -> abbbabababba

# < a,b | bbabbbababbaaa=a >
bbabbbababbaaa -> a

# < a,b | bbabbbababbaba=a >
bbabbbababbaba -> a

# < a,b | bbabbbababbbaa=a >
bbabbbababbbaa -> a

# < a,b | bbabbbababbbba=a >
bbabbbababbbba -> a
bbabbbababba -> abbbababbbba
bbabbbabaa -> abbbababba

# < a,b | bbabbbabbaaaaa=a >
bbabbbabbaaaaa -> a

# < a,b | bbabbbabbaaaba=a >
bbabbbabbaaaba -> a

# < a,b | bbabbbabbaabaa=a >
bbabbbabbaabaa -> a

# < a,b | bbabbbabbaabba=a >
bbabbbabbaabba -> a
bbabbbabbaaa -> abbbabbaabba

# < a,b | bbabbbabbabaaa=a >
bbabbbabbabaaa -> a

# < a,b | bbabbbabbababa=a >
bbabbbabbababa -> a

# < a,b | bbabbbabbabbaa=a >
bbabbbabbabbaa -> a

# < a,b | bbabbbabbabbba=a >
bbabbbabbabbba -> a
bbabbbabbaba -> abbbabbabbba
bbabbbaa -> abbabbba

# < a,b | bbabbbabbbaaaa=a >
bbabbbabbbaaaa -> a

# < a,b | bbabbbabbbaaba=a >
bbabbbabbbaaba -> a

# < a,b | bbabbbabbbabaa=a >
bbabbbabbbabaa -> a

# < a,b | bbabbbabbbabba=a >
bbabbbabbbabba -> a
bbabbbabbbaa -> abbbabbbabba

# < a,b | bbabbbabbbbaaa=a >
bbabbbabbbbaaa -> a

# < a,b | bbabbbabbbbaba=a >
bbabbbabbbbaba -> a

# < a,b | bbabbbabbbbbaa=a >
bbabbbabbbbbaa -> a

# < a,b | bbabbbabbbbbba=a >
bbabbbabbbbbba -> a
bbabbbabbbba -> abbbabbbbbba
bbabbbabba -> abbbabbbba
bbabbbaa -> abbbabba

# < a,b | bbabbbbaaaaaaa=a >
bbabbbbaaaaaaa -> a

# < a,b | bbabbbbaaaaaba=a >
bbabbbbaaaaaba -> a

# < a,b | bbabbbbaaaabaa=a >
bbabbbbaaaabaa -> a

# < a,b | bbabbbbaaaabba=a >
bbabbbbaaaabba -> a
bbabbbbaaaaa -> abbbbaaaabba

# < a,b | bbabbbbaaabaaa=a >
bbabbbbaaabaaa -> a

# < a,b | bbabbbbaaababa=a >
bbabbbbaaababa -> a

# < a,b | bbabbbbaaabbaa=a >
bbabbbbaaabbaa -> a

# < a,b | bbabbbbaaabbba=a >
bbabbbbaaabbba -> a
bbabbbbaaaba -> abbbbaaabbba

# < a,b | bbabbbbaabaaaa=a >
bbabbbbaabaaaa -> a

# < a,b | bbabbbbaabaaba=a >
bbabbbbaabaaba -> a

# < a,b | bbabbbbaababaa=a >
bbabbbbaababaa -> a

# < a,b | bbabbbbaababba=a >
bbabbbbaababba -> a
bbabbbbaabaa -> abbbbaababba

# < a,b | bbabbbbaabbaaa=a >
bbabbbbaabbaaa -> a

# < a,b | bbabbbbaabbaba=a >
bbabbbbaabbaba -> a

# < a,b | bbabbbbaabbbaa=a >
bbabbbbaabbbaa -> a

# < a,b | bbabbbbaabbbba=a >
bbabbbbaabbbba -> a
bbabbbbaabba -> abbbbaabbbba
bbabbbbaaa -> abbbbaabba

# < a,b | bbabbbbabaaaaa=a >
bbabbbbabaaaaa -> a

# < a,b | bbabbbbabaaaba=a >
bbabbbbabaaaba -> a

# < a,b | bbabbbbabaabaa=a >
bbabbbbabaabaa -> a

# < a,b | bbabbbbabaabba=a >
bbabbbbabaabba -> a
bbabbbbabaaa -> abbbbabaabba

# < a,b | bbabbbbababaaa=a >
bbabbbbababaaa -> a

# < a,b | bbabbbbabababa=a >
bbabbbbabababa -> a

# < a,b | bbabbbbababbaa=a >
bbabbbbababbaa -> a

# < a,b | bbabbbbababbba=a >
bbabbbbababbba -> a
bbabbbbababa -> abbbbababbba

# < a,b | bbabbbbabbaaaa=a >
bbabbbbabbaaaa -> a

# < a,b | bbabbbbabbaaba=a >
bbabbbbabbaaba -> a

# < a,b | bbabbbbabbabaa=a >
bbabbbbabbabaa -> a

# < a,b | bbabbbbabbabba=a >
bbabbbbabbabba -> a
bbabbbbabbaa -> abbbbabbabba

# < a,b | bbabbbbabbbaaa=a >
bbabbbbabbbaaa -> a

# < a,b | bbabbbbabbbaba=a >
bbabbbbabbbaba -> a

# < a,b | bbabbbbabbbbaa=a >
bbabbbbabbbbaa -> a

# < a,b | bbabbbbabbbbba=a >
bbabbbbabbbbba -> a
bbabbbbabbba -> abbbbabbbbba
bbabbbbaba -> abbbbabbba

# < a,b | bbabbbbbaaaaaa=a >
bbabbbbbaaaaaa -> a

# < a,b | bbabbbbbaaaaba=a >
bbabbbbbaaaaba -> a

# < a,b | bbabbbbbaaabaa=a >
bbabbbbbaaabaa -> a

# < a,b | bbabbbbbaaabba=a >
bbabbbbbaaabba -> a
bbabbbbbaaaa -> abbbbbaaabba

# < a,b | bbabbbbbaabaaa=a >
bbabbbbbaabaaa -> a

# < a,b | bbabbbbbaababa=a >
bbabbbbbaababa -> a

# < a,b | bbabbbbbaabbaa=a >
bbabbbbbaabbaa -> a

# < a,b | bbabbbbbaabbba=a >
bbabbbbbaabbba -> a
bbabbbbbaaba -> abbbbbaabbba

# < a,b | bbabbbbbabaaaa=a >
bbabbbbbabaaaa -> a

# < a,b | bbabbbbbabaaba=a >
bbabbbbbabaaba -> a

# < a,b | bbabbbbbababaa=a >
bbabbbbbababaa -> a

# < a,b | bbabbbbbababba=a >
bbabbbbbababba -> a
bbabbbbbabaa -> abbbbbababba

# < a,b | bbabbbbbabbaaa=a >
bbabbbbbabbaaa -> a

# < a,b | bbabbbbbabbaba=a >
bbabbbbbabbaba -> a

# < a,b | bbabbbbbabbbaa=a >
bbabbbbbabbbaa -> a

# < a,b | bbabbbbbabbbba=a >
bbabbbbbabbbba -> a
bbabbbbbabba -> abbbbbabbbba
bbabbbbbaa -> abbbbbabba

# < a,b | bbabbbbbbaaaaa=a >
bbabbbbbbaaaaa -> a

# < a,b | bbabbbbbbaaaba=a >
bbabbbbbbaaaba -> a

# < a,b | bbabbbbbbaabaa=a >
bbabbbbbbaabaa -> a

# < a,b | bbabbbbbbaabba=a >
bbabbbbbbaabba -> a
bbabbbbbbaaa -> abbbbbbaabba

# < a,b | bbabbbbbbabaaa=a >
bbabbbbbbabaaa -> a

# < a,b | bbabbbbbbababa=a >
bbabbbbbbababa -> a

# < a,b | bbabbbbbbabbaa=a >
bbabbbbbbabbaa -> a

# < a,b | bbabbbbbbabbba=a >
bbabbbbbbabbba -> a
bbabbbbbbaba -> abbbbbbabbba

# < a,b | bbabbbbbbbaaaa=a >
bbabbbbbbbaaaa -> a

# < a,b | bbabbbbbbbaaba=a >
bbabbbbbbbaaba -> a

# < a,b | bbabbbbbbbabaa=a >
bbabbbbbbbabaa -> a

# < a,b | bbabbbbbbbabba=a >
bbabbbbbbbabba -> a
bbabbbbbbbaa -> abbbbbbbabba

# < a,b | bbabbbbbbbbaaa=a >
bbabbbbbbbbaaa -> a

# < a,b | bbabbbbbbbbaba=a >
bbabbbbbbbbaba -> a

# < a,b | bbabbbbbbbbbaa=a >
bbabbbbbbbbbaa -> a

# < a,b | bbabbbbbbbbbba=a >
bbabbbbbbbbbba -> a
bbabbbbbbbba -> abbbbbbbbbba
bbabbbbbba -> abbbbbbbba
bbabbbba -> abbbbbba
bbabba -> abbbba
bbaa -> abba

# < a,b | bbbaaaaaaaaaaa=a >
bbbaaaaaaaaaaa -> a

# < a,b | bbbaaaaaaaaaba=a >
bbbaaaaaaaaaba -> a

# < a,b | bbbaaaaaaaabaa=a >
bbbaaaaaaaabaa -> a

# < a,b | bbbaaaaaaaabba=a >
bbbaaaaaaaabba -> a

# < a,b | bbbaaaaaaabaaa=a >
bbbaaaaaaabaaa -> a

# < a,b | bbbaaaaaaababa=a >
bbbaaaaaaababa -> a

# < a,b | bbbaaaaaaabbaa=a >
bbbaaaaaaabbaa -> a

# < a,b | bbbaaaaaaabbba=a >
bbbaaaaaaabbba -> a
bbbaaaaaaaa -> aaaaaaabbba

# < a,b | bbbaaaaaabaaaa=a >
bbbaaaaaabaaaa -> a

# < a,b | bbbaaaaaabaaba=a >
bbbaaaaaabaaba -> a

# < a,b | bbbaaaaaababaa=a >
bbbaaaaaababaa -> a

# < a,b | bbbaaaaaababba=a >
bbbaaaaaababba -> a

# < a,b | bbbaaaaaabbaaa=a >
bbbaaaaaabbaaa -> a

# < a,b | bbbaaaaaabbaba=a >
bbbaaaaaabbaba -> a

# < a,b | bbbaaaaaabbbaa=a >
bbbaaaaaabbbaa -> a
bbbaaaaaaa -> aaaaabbbaa

# < a,b | bbbaaaaaabbbba=a >
bbbaaaaaabbbba -> a
bbbaaaaaaba -> aaaaaabbbba

# < a,b | bbbaaaaabaaaaa=a >
bbbaaaaabaaaaa -> a

# < a,b | bbbaaaaabaaaba=a >
bbbaaaaabaaaba -> a

# < a,b | bbbaaaaabaabaa=a >
bbbaaaaabaabaa -> a

# < a,b | bbbaaaaabaabba=a >
bbbaaaaabaabba -> a

# < a,b | bbbaaaaababaaa=a >
bbbaaaaababaaa -> a

# < a,b | bbbaaaaabababa=a >
bbbaaaaabababa -> a

# < a,b | bbbaaaaababbaa=a >
bbbaaaaababbaa -> a

# < a,b | bbbaaaaababbba=a >
bbbaaaaababbba -> a
bbbaaaaabaa -> aaaaababbba

# < a,b | bbbaaaaabbaaaa=a >
bbbaaaaabbaaaa -> a

# < a,b | bbbaaaaabbaaba=a >
bbbaaaaabbaaba -> a

# < a,b | bbbaaaaabbabaa=a >
bbbaaaaabbabaa -> a

# < a,b | bbbaaaaabbabba=a >
bbbaaaaabbabba -> a

# < a,b | bbbaaaaabbbaaa=a >
bbbaaaaabbbaaa -> a
bbbaaaaaa -> aaabbbaaa

# < a,b | bbbaaaaabbbaba=a >
bbbaaaaabbbaba -> a

# < a,b | bbbaaaaabbbbaa=a >
bbbaaaaabbbbaa -> a
bbbaaaaaba -> aaaabbbbaa

# < a,b | bbbaaaaabbbbba=a >
bbbaaaaabbbbba -> a
bbbaaaaabba -> aaaaabbbbba

# < a,b | bbbaaaabaaaaaa=a >
bbbaaaabaaaaaa -> a

# < a,b | bbbaaaabaaaaba=a >
bbbaaaabaaaaba -> a

# < a,b | bbbaaaabaaabaa=a >
bbbaaaabaaabaa -> a

# < a,b | bbbaaaabaaabba=a >
bbbaaaabaaabba -> a

# < a,b | bbbaaaabaabaaa=a >
bbbaaaabaabaaa -> a

# < a,b | bbbaaaabaababa=a >
bbbaaaabaababa -> a

# < a,b | bbbaaaabaabbaa=a >
bbbaaaabaabbaa -> a

# < a,b | bbbaaaabaabbba=a >
bbbaaaabaabbba -> a
bbbaaaabaaa -> aaaabaabbba

# < a,b | bbbaaaababaaaa=a >
bbbaaaababaaaa -> a

# < a,b | bbbaaaababaaba=a >
bbbaaaababaaba -> a

# < a,b | bbbaaaabababaa=a >
bbbaaaabababaa -> a

# < a,b | bbbaaaabababba=a >
bbbaaaabababba -> a

# < a,b | bbbaaaababbaaa=a >
bbbaaaababbaaa -> a

# < a,b | bbbaaaababbaba=a >
bbbaaaababbaba -> a

# < a,b | bbbaaaababbbaa=a >
bbbaaaababbbaa -> a
bbbaaaabaa -> aaababbbaa

# < a,b | bbbaaaababbbba=a >
bbbaaaababbbba -> a
bbbaaaababa -> aaaababbbba

# < a,b | bbbaaaabbaaaaa=a >
bbbaaaabbaaaaa -> a

# < a,b | bbbaaaabbaaaba=a >
bbbaaaabbaaaba -> a

# < a,b | bbbaaaabbaabaa=a >
bbbaaaabbaabaa -> a

# < a,b | bbbaaaabbaabba=a >
bbbaaaabbaabba -> a

# < a,b | bbbaaaabbabaaa=a >
bbbaaaabbabaaa -> a

# < a,b | bbbaaaabbababa=a >
bbbaaaabbababa -> a

# < a,b | bbbaaaabbabbaa=a >
bbbaaaabbabbaa -> a

# < a,b | bbbaaaabbabbba=a >
bbbaaaabbabbba -> a
bbbaaaabbaa -> aaaabbabbba

# < a,b | bbbaaaabbbaaaa=a >
bbbaaaabbbaaaa -> a
bbbaaaaa -> abbbaaaa

# < a,b | bbbaaaabbbaaba=a >
bbbaaaabbbaaba -> a

# < a,b | bbbaaaabbbabaa=a >
bbbaaaabbbabaa -> a

# < a,b | bbbaaaabbbabba=a >
bbbaaaabbbabba -> a

# < a,b | bbbaaaabbbbaaa=a >
bbbaaaabbbbaaa -> a
bbbaaaaba -> aabbbbaaa

# < a,b | bbbaaaabbbbaba=a >
bbbaaaabbbbaba -> a

# < a,b | bbbaaaabbbbbaa=a >
bbbaaaabbbbbaa -> a
bbbaaaabba -> aaabbbbbaa

# < a,b | bbbaaaabbbbbba=a >
bbbaaaabbbbbba -> a
bbbaaaabbba -> aaaabbbbbba
bbbaaaaa -> aaaabbba

# < a,b | bbbaaabaaaaaaa=a >
bbbaaabaaaaaaa -> a

# < a,b | bbbaaabaaaaaba=a >
bbbaaabaaaaaba -> a

# < a,b | bbbaaabaaaabaa=a >
bbbaaabaaaabaa -> a

# < a,b | bbbaaabaaaabba=a >
bbbaaabaaaabba -> a

# < a,b | bbbaaabaaabaaa=a >
bbbaaabaaabaaa -> a

# < a,b | bbbaaabaaababa=a >
bbbaaabaaababa -> a

# < a,b | bbbaaabaaabbaa=a >
bbbaaabaaabbaa -> a

# < a,b | bbbaaabaaabbba=a >
bbbaaabaaabbba -> a
bbbaaabaaaa -> aaabaaabbba

# < a,b | bbbaaabaabaaaa=a >
bbbaaabaabaaaa -> a

# < a,b | bbbaaabaabaaba=a >
bbbaaabaabaaba -> a

# < a,b | bbbaaabaababaa=a >
bbbaaabaababaa -> a

# < a,b | bbbaaabaababba=a >
bbbaaabaababba -> a

# < a,b | bbbaaabaabbaaa=a >
bbbaaabaabbaaa -> a

# < a,b | bbbaaabaabbaba=a >
bbbaaabaabbaba -> a

# < a,b | bbbaaabaabbbaa=a >
bbbaaabaabbbaa -> a
bbbaaabaaa -> aabaabbbaa

# < a,b | bbbaaabaabbbba=a >
bbbaaabaabbbba -> a
bbbaaabaaba -> aaabaabbbba

# < a,b | bbbaaababaaaaa=a >
bbbaaababaaaaa -> a

# < a,b | bbbaaababaaaba=a >
bbbaaababaaaba -> a

# < a,b | bbbaaababaabaa=a >
bbbaaababaabaa -> a

# < a,b | bbbaaababaabba=a >
bbbaaababaabba -> a

# < a,b | bbbaaabababaaa=a >
bbbaaabababaaa -> a

# < a,b | bbbaaababababa=a >
bbbaaababababa -> a

# < a,b | bbbaaabababbaa=a >
bbbaaabababbaa -> a

# < a,b | bbbaaabababbba=a >
bbbaaabababbba -> a
bbbaaababaa -> aaabababbba

# < a,b | bbbaaababbaaaa=a >
bbbaaababbaaaa -> a

# < a,b | bbbaaababbaaba=a >
bbbaaababbaaba -> a

# < a,b | bbbaaababbabaa=a >
bbbaaababbabaa -> a

# < a,b | bbbaaababbabba=a >
bbbaaababbabba -> a

# < a,b | bbbaaababbbaaa=a >
bbbaaababbbaaa -> a
bbbaaabaa -> ababbbaaa

# < a,b | bbbaaababbbaba=a >
bbbaaababbbaba -> a

# < a,b | bbbaaababbbbaa=a >
bbbaaababbbbaa -> a
bbbaaababa -> aababbbbaa

# < a,b | bbbaaababbbbba=a >
bbbaaababbbbba -> a
bbbaaababba -> aaababbbbba

# < a,b | bbbaaabbaaaaaa=a >
bbbaaabbaaaaaa -> a

# < a,b | bbbaaabbaaaaba=a >
bbbaaabbaaaaba -> a

# < a,b | bbbaaabbaaabaa=a >
bbbaaabbaaabaa -> a

# < a,b | bbbaaabbaaabba=a >
bbbaaabbaaabba -> a

# < a,b | bbbaaabbaabaaa=a >
bbbaaabbaabaaa -> a

# < a,b | bbbaaabbaababa=a >
bbbaaabbaababa -> a

# < a,b | bbbaaabbaabbaa=a >
bbbaaabbaabbaa -> a

# < a,b | bbbaaabbaabbba=a >
bbbaaabbaabbba -> a
bbbaaabbaaa -> aaabbaabbba

# < a,b | bbbaaabbabaaaa=a >
bbbaaabbabaaaa -> a

# < a,b | bbbaaabbabaaba=a >
bbbaaabbabaaba -> a

# < a,b | bbbaaabbababaa=a >
bbbaaabbababaa -> a

# < a,b | bbbaaabbababba=a >
bbbaaabbababba -> a

# < a,b | bbbaaabbabbaaa=a >
bbbaaabbabbaaa -> a

# < a,b | bbbaaabbabbaba=a >
bbbaaabbabbaba -> a

# < a,b | bbbaaabbabbbaa=a >
bbbaaabbabbbaa -> a
bbbaaabbaa -> aabbabbbaa

# < a,b | bbbaaabbabbbba=a >
bbbaaabbabbbba -> a
bbbaaabbaba -> aaabbabbbba

# < a,b | bbbaaabbbaaaaa=a >
bbbaaabbbaaaaa -> a

# < a,b | bbbaaabbbaaaba=a >
bbbaaabbbaaaba -> a

# < a,b | bbbaaabbbaabaa=a >
bbbaaabbbaabaa -> a

# < a,b | bbbaaabbbaabba=a >
bbbaaabbbaabba -> a

# < a,b | bbbaaabbbabaaa=a >
bbbaaabbbabaaa -> a

# < a,b | bbbaaabbbababa=a >
bbbaaabbbababa -> a

# < a,b | bbbaaabbbabbaa=a >
bbbaaabbbabbaa -> a

# < a,b | bbbaaabbbbaaaa=a >
bbbaaabbbbaaaa -> a

# < a,b | bbbaaabbbbaaba=a >
bbbaaabbbbaaba -> a

# < a,b | bbbaaabbbbabaa=a >
bbbaaabbbbabaa -> a

# < a,b | bbbaaabbbbabba=a >
bbbaaabbbbabba -> a

# < a,b | bbbaaabbbbbaaa=a >
bbbaaabbbbbaaa -> a
bbbaaabba -> abbbbbaaa

# < a,b | bbbaaabbbbbaba=a >
bbbaaabbbbbaba -> a

# < a,b | bbbaaabbbbbbba=a >
bbbaaabbbbbbba -> a
bbbaaabbbba -> aaabbbbbbba
bbbaaaba -> aaabbbba

# < a,b | bbbaabaaaaaaaa=a >
bbbaabaaaaaaaa -> a

# < a,b | bbbaabaaaaaaba=a >
bbbaabaaaaaaba -> a

# < a,b | bbbaabaaaaabaa=a >
bbbaabaaaaabaa -> a

# < a,b | bbbaabaaaaabba=a >
bbbaabaaaaabba -> a

# < a,b | bbbaabaaaabaaa=a >
bbbaabaaaabaaa -> a

# < a,b | bbbaabaaaababa=a >
bbbaabaaaababa -> a

# < a,b | bbbaabaaaabbaa=a >
bbbaabaaaabbaa -> a

# < a,b | bbbaabaaaabbba=a >
bbbaabaaaabbba -> a
bbbaabaaaaa -> aabaaaabbba

# < a,b | bbbaabaaabaaaa=a >
bbbaabaaabaaaa -> a

# < a,b | bbbaabaaabaaba=a >
bbbaabaaabaaba -> a

# < a,b | bbbaabaaababaa=a >
bbbaabaaababaa -> a

# < a,b | bbbaabaaababba=a >
bbbaabaaababba -> a

# < a,b | bbbaabaaabbaaa=a >
bbbaabaaabbaaa -> a

# < a,b | bbbaabaaabbaba=a >
bbbaabaaabbaba -> a

# < a,b | bbbaabaaabbbaa=a >
bbbaabaaabbbaa -> a
bbbaabaaaa -> abaaabbbaa

# < a,b | bbbaabaaabbbba=a >
bbbaabaaabbbba -> a
bbbaabaaaba -> aabaaabbbba

# < a,b | bbbaabaabaaaaa=a >
bbbaabaabaaaaa -> a

# < a,b | bbbaabaabaaaba=a >
bbbaabaabaaaba -> a

# < a,b | bbbaabaabaabaa=a >
bbbaabaabaabaa -> a

# < a,b | bbbaabaabaabba=a >
bbbaabaabaabba -> a

# < a,b | bbbaabaababaaa=a >
bbbaabaababaaa -> a

# < a,b | bbbaabaabababa=a >
bbbaabaabababa -> a

# < a,b | bbbaabaababbaa=a >
bbbaabaababbaa -> a

# < a,b | bbbaabaababbba=a >
bbbaabaababbba -> a
bbbaabaabaa -> aabaababbba

# < a,b | bbbaabaabbaaaa=a >
bbbaabaabbaaaa -> a

# < a,b | bbbaabaabbaaba=a >
bbbaabaabbaaba -> a

# < a,b | bbbaabaabbabaa=a >
bbbaabaabbabaa -> a

# < a,b | bbbaabaabbabba=a >
bbbaabaabbabba -> a

# < a,b | bbbaabaabbbaaa=a >
bbbaabaabbbaaa -> a

# < a,b | bbbaabaabbbaba=a >
bbbaabaabbbaba -> a

# < a,b | bbbaabaabbbbaa=a >
bbbaabaabbbbaa -> a
bbbaabaaba -> abaabbbbaa

# < a,b | bbbaabaabbbbba=a >
bbbaabaabbbbba -> a
bbbaabaabba -> aabaabbbbba

# < a,b | bbbaababaaaaaa=a >
bbbaababaaaaaa -> a

# < a,b | bbbaababaaaaba=a >
bbbaababaaaaba -> a

# < a,b | bbbaababaaabaa=a >
bbbaababaaabaa -> a

# < a,b | bbbaababaaabba=a >
bbbaababaaabba -> a

# < a,b | bbbaababaabaaa=a >
bbbaababaabaaa -> a

# < a,b | bbbaababaababa=a >
bbbaababaababa -> a

# < a,b | bbbaababaabbaa=a >
bbbaababaabbaa -> a

# < a,b | bbbaababaabbba=a >
bbbaababaabbba -> a
bbbaababaaa -> aababaabbba

# < a,b | bbbaabababaaaa=a >
bbbaabababaaaa -> a

# < a,b | bbbaabababaaba=a >
bbbaabababaaba -> a

# < a,b | bbbaababababaa=a >
bbbaababababaa -> a

# < a,b | bbbaababababba=a >
bbbaababababba -> a

# < a,b | bbbaabababbaaa=a >
bbbaabababbaaa -> a

# < a,b | bbbaabababbaba=a >
bbbaabababbaba -> a

# < a,b | bbbaabababbbaa=a >
bbbaabababbbaa -> a
bbbaababaa -> abababbbaa

# < a,b | bbbaabababbbba=a >
bbbaabababbbba -> a
bbbaabababa -> aabababbbba

# < a,b | bbbaababbaaaaa=a >
bbbaababbaaaaa -> a

# < a,b | bbbaababbaaaba=a >
bbbaababbaaaba -> a

# < a,b | bbbaababbaabaa=a >
bbbaababbaabaa -> a

# < a,b | bbbaababbaabba=a >
bbbaababbaabba -> a

# < a,b | bbbaababbabaaa=a >
bbbaababbabaaa -> a

# < a,b | bbbaababbababa=a >
bbbaababbababa -> a

# < a,b | bbbaababbabbaa=a >
bbbaababbabbaa -> a

# < a,b | bbbaababbabbba=a >
bbbaababbabbba -> a
bbbaababbaa -> aababbabbba

# < a,b | bbbaababbbaaaa=a >
bbbaababbbaaaa -> a

# < a,b | bbbaababbbaaba=a >
bbbaababbbaaba -> a
bbbaabaa -> abbbaaba

# < a,b | bbbaababbbabaa=a >
bbbaababbbabaa -> a

# < a,b | bbbaababbbabba=a >
bbbaababbbabba -> a

# < a,b | bbbaababbbbaaa=a >
bbbaababbbbaaa -> a

# < a,b | bbbaababbbbaba=a >
bbbaababbbbaba -> a

# < a,b | bbbaababbbbbaa=a >
bbbaababbbbbaa -> a
bbbaababba -> ababbbbbaa

# < a,b | bbbaababbbbbba=a >
bbbaababbbbbba -> a
bbbaababbba -> aababbbbbba
bbbaabaa -> aababbba

# < a,b | bbbaabbaaaaaaa=a >
bbbaabbaaaaaaa -> a

# < a,b | bbbaabbaaaaaba=a >
bbbaabbaaaaaba -> a

# < a,b | bbbaabbaaaabaa=a >
bbbaabbaaaabaa -> a

# < a,b | bbbaabbaaaabba=a >
bbbaabbaaaabba -> a

# < a,b | bbbaabbaaabaaa=a >
bbbaabbaaabaaa -> a

# < a,b | bbbaabbaaababa=a >
bbbaabbaaababa -> a

# < a,b | bbbaabbaaabbaa=a >
bbbaabbaaabbaa -> a

# < a,b | bbbaabbaaabbba=a >
bbbaabbaaabbba -> a
bbbaabbaaaa -> aabbaaabbba

# < a,b | bbbaabbaabaaaa=a >
bbbaabbaabaaaa -> a

# < a,b | bbbaabbaabaaba=a >
bbbaabbaabaaba -> a

# < a,b | bbbaabbaababaa=a >
bbbaabbaababaa -> a

# < a,b | bbbaabbaababba=a >
bbbaabbaababba -> a

# < a,b | bbbaabbaabbaaa=a >
bbbaabbaabbaaa -> a

# < a,b | bbbaabbaabbaba=a >
bbbaabbaabbaba -> a

# < a,b | bbbaabbaabbbaa=a >
bbbaabbaabbbaa -> a
bbbaabbaaa -> abbaabbbaa

# < a,b | bbbaabbaabbbba=a >
bbbaabbaabbbba -> a
bbbaabbaaba -> aabbaabbbba

# < a,b | bbbaabbabaaaaa=a >
bbbaabbabaaaaa -> a

# < a,b | bbbaabbabaaaba=a >
bbbaabbabaaaba -> a

# < a,b | bbbaabbabaabaa=a >
bbbaabbabaabaa -> a

# < a,b | bbbaabbabaabba=a >
bbbaabbabaabba -> a

# < a,b | bbbaabbababaaa=a >
bbbaabbababaaa -> a

# < a,b | bbbaabbabababa=a >
bbbaabbabababa -> a

# < a,b | bbbaabbababbaa=a >
bbbaabbababbaa -> a

# < a,b | bbbaabbababbba=a >
bbbaabbababbba -> a
bbbaabbabaa -> aabbababbba

# < a,b | bbbaabbabbaaaa=a >
bbbaabbabbaaaa -> a

# < a,b | bbbaabbabbaaba=a >
bbbaabbabbaaba -> a

# < a,b | bbbaabbabbabaa=a >
bbbaabbabbabaa -> a

# < a,b | bbbaabbabbabba=a >
bbbaabbabbabba -> a

# < a,b | bbbaabbabbbaaa=a >
bbbaabbabbbaaa -> a

# < a,b | bbbaabbabbbaba=a >
bbbaabbabbbaba -> a

# < a,b | bbbaabbabbbbaa=a >
bbbaabbabbbbaa -> a
bbbaabbaba -> abbabbbbaa

# < a,b | bbbaabbabbbbba=a >
bbbaabbabbbbba -> a
bbbaabbabba -> aabbabbbbba

# < a,b | bbbaabbbaaaaaa=a >
bbbaabbbaaaaaa -> a

# < a,b | bbbaabbbaaaaba=a >
bbbaabbbaaaaba -> a

# < a,b | bbbaabbbaaabaa=a >
bbbaabbbaaabaa -> a

# < a,b | bbbaabbbaaabba=a >
bbbaabbbaaabba -> a

# < a,b | bbbaabbbaabaaa=a >
bbbaabbbaabaaa -> a

# < a,b | bbbaabbbaababa=a >
bbbaabbbaababa -> a

# < a,b | bbbaabbbaabbaa=a >
bbbaabbbaabbaa -> a

# < a,b | bbbaabbbaabbba=a >
bbbaabbbaabbba -> a
bbbaaa -> aabbba

# < a,b | bbbaabbbabaaaa=a >
bbbaabbbabaaaa -> a

# < a,b | bbbaabbbabaaba=a >
bbbaabbbabaaba -> a

# < a,b | bbbaabbbababaa=a >
bbbaabbbababaa -> a

# < a,b | bbbaabbbababba=a >
bbbaabbbababba -> a

# < a,b | bbbaabbbabbaaa=a >
bbbaabbbabbaaa -> a

# < a,b | bbbaabbbabbaba=a >
bbbaabbbabbaba -> a

# < a,b | bbbaabbbabbbaa=a >
bbbaabbbabbbaa -> a
bbbaabbbaa -> abbbabbbaa
bbbaaa -> abbbaa

# < a,b | bbbaabbbabbbba=a >
bbbaabbbabbbba -> a
bbbaabbbaba -> aabbbabbbba

# < a,b | bbbaabbbbaaaaa=a >
bbbaabbbbaaaaa -> a

# < a,b | bbbaabbbbaaaba=a >
bbbaabbbbaaaba -> a

# < a,b | bbbaabbbbaabaa=a >
bbbaabbbbaabaa -> a

# < a,b | bbbaabbbbaabba=a >
bbbaabbbbaabba -> a

# < a,b | bbbaabbbbabaaa=a >
bbbaabbbbabaaa -> a

# < a,b | bbbaabbbbababa=a >
bbbaabbbbababa -> a

# < a,b | bbbaabbbbabbaa=a >
bbbaabbbbabbaa -> a

# < a,b | bbbaabbbbbaaaa=a >
bbbaabbbbbaaaa -> a

# < a,b | bbbaabbbbbaaba=a >
bbbaabbbbbaaba -> a

# < a,b | bbbaabbbbbabaa=a >
bbbaabbbbbabaa -> a

# < a,b | bbbaabbbbbabba=a >
bbbaabbbbbabba -> a

# < a,b | bbbaabbbbbbaaa=a >
bbbaabbbbbbaaa -> a

# < a,b | bbbaabbbbbbaba=a >
bbbaabbbbbbaba -> a

# < a,b | bbbaabbbbbbbba=a >
bbbaabbbbbbbba -> a
bbbaabbbbba -> aabbbbbbbba
bbbaabba -> aabbbbba

# < a,b | bbbabaaaaaaaaa=a >
bbbabaaaaaaaaa -> a

# < a,b | bbbabaaaaaaaba=a >
bbbabaaaaaaaba -> a

# < a,b | bbbabaaaaaabaa=a >
bbbabaaaaaabaa -> a

# < a,b | bbbabaaaaaabba=a >
bbbabaaaaaabba -> a

# < a,b | bbbabaaaaabaaa=a >
bbbabaaaaabaaa -> a

# < a,b | bbbabaaaaababa=a >
bbbabaaaaababa -> a

# < a,b | bbbabaaaaabbaa=a >
bbbabaaaaabbaa -> a

# < a,b | bbbabaaaaabbba=a >
bbbabaaaaabbba -> a
bbbabaaaaaa -> abaaaaabbba

# < a,b | bbbabaaaabaaaa=a >
bbbabaaaabaaaa -> a

# < a,b | bbbabaaaabaaba=a >
bbbabaaaabaaba -> a

# < a,b | bbbabaaaababaa=a >
bbbabaaaababaa -> a

# < a,b | bbbabaaaababba=a >
bbbabaaaababba -> a

# < a,b | bbbabaaaabbaaa=a >
bbbabaaaabbaaa -> a

# < a,b | bbbabaaaabbaba=a >
bbbabaaaabbaba -> a

# < a,b | bbbabaaaabbbaa=a >
bbbabaaaabbbaa -> a

# < a,b | bbbabaaaabbbba=a >
bbbabaaaabbbba -> a
bbbabaaaaba -> abaaaabbbba

# < a,b | bbbabaaabaaaaa=a >
bbbabaaabaaaaa -> a

# < a,b | bbbabaaabaaaba=a >
bbbabaaabaaaba -> a

# < a,b | bbbabaaabaabaa=a >
bbbabaaabaabaa -> a

# < a,b | bbbabaaabaabba=a >
bbbabaaabaabba -> a

# < a,b | bbbabaaababaaa=a >
bbbabaaababaaa -> a

# < a,b | bbbabaaabababa=a >
bbbabaaabababa -> a

# < a,b | bbbabaaababbaa=a >
bbbabaaababbaa -> a

# < a,b | bbbabaaababbba=a >
bbbabaaababbba -> a
bbbabaaabaa -> abaaababbba

# < a,b | bbbabaaabbaaaa=a >
bbbabaaabbaaaa -> a

# < a,b | bbbabaaabbaaba=a >
bbbabaaabbaaba -> a

# < a,b | bbbabaaabbabaa=a >
bbbabaaabbabaa -> a

# < a,b | bbbabaaabbabba=a >
bbbabaaabbabba -> a

# < a,b | bbbabaaabbbaaa=a >
bbbabaaabbbaaa -> a

# < a,b | bbbabaaabbbaba=a >
bbbabaaabbbaba -> a
bbbabaaaa -> aaabbbaba

# < a,b | bbbabaaabbbbaa=a >
bbbabaaabbbbaa -> a

# < a,b | bbbabaaabbbbba=a >
bbbabaaabbbbba -> a
bbbabaaabba -> abaaabbbbba

# < a,b | bbbabaabaaaaaa=a >
bbbabaabaaaaaa -> a

# < a,b | bbbabaabaaaaba=a >
bbbabaabaaaaba -> a

# < a,b | bbbabaabaaabaa=a >
bbbabaabaaabaa -> a

# < a,b | bbbabaabaaabba=a >
bbbabaabaaabba -> a

# < a,b | bbbabaabaabaaa=a >
bbbabaabaabaaa -> a

# < a,b | bbbabaabaababa=a >
bbbabaabaababa -> a

# < a,b | bbbabaabaabbaa=a >
bbbabaabaabbaa -> a

# < a,b | bbbabaabaabbba=a >
bbbabaabaabbba -> a
bbbabaabaaa -> abaabaabbba

# < a,b | bbbabaababaaaa=a >
bbbabaababaaaa -> a

# < a,b | bbbabaababaaba=a >
bbbabaababaaba -> a

# < a,b | bbbabaabababaa=a >
bbbabaabababaa -> a

# < a,b | bbbabaabababba=a >
bbbabaabababba -> a

# < a,b | bbbabaababbaaa=a >
bbbabaababbaaa -> a

# < a,b | bbbabaababbaba=a >
bbbabaababbaba -> a

# < a,b | bbbabaababbbaa=a >
bbbabaababbbaa -> a

# < a,b | bbbabaababbbba=a >
bbbabaababbbba -> a
bbbabaababa -> abaababbbba

# < a,b | bbbabaabbaaaaa=a >
bbbabaabbaaaaa -> a

# < a,b | bbbabaabbaaaba=a >
bbbabaabbaaaba -> a

# < a,b | bbbabaabbaabaa=a >
bbbabaabbaabaa -> a

# < a,b | bbbabaabbaabba=a >
bbbabaabbaabba -> a

# < a,b | bbbabaabbabaaa=a >
bbbabaabbabaaa -> a

# < a,b | bbbabaabbababa=a >
bbbabaabbababa -> a

# < a,b | bbbabaabbabbaa=a >
bbbabaabbabbaa -> a

# < a,b | bbbabaabbabbba=a >
bbbabaabbabbba -> a
bbbabaabbaa -> abaabbabbba

# < a,b | bbbabaabbbaaaa=a >
bbbabaabbbaaaa -> a

# < a,b | bbbabaabbbaaba=a >
bbbabaabbbaaba -> a

# < a,b | bbbabaabbbabaa=a >
bbbabaabbbabaa -> a
bbbabaaa -> abbbabaa

# < a,b | bbbabaabbbabba=a >
bbbabaabbbabba -> a

# < a,b | bbbabaabbbbaaa=a >
bbbabaabbbbaaa -> a

# < a,b | bbbabaabbbbaba=a >
bbbabaabbbbaba -> a
bbbabaaba -> aabbbbaba

# < a,b | bbbabaabbbbbaa=a >
bbbabaabbbbbaa -> a

# < a,b | bbbabaabbbbbba=a >
bbbabaabbbbbba -> a
bbbabaabbba -> abaabbbbbba
bbbabaaa -> abaabbba

# < a,b | bbbababaaaaaaa=a >
bbbababaaaaaaa -> a

# < a,b | bbbababaaaaaba=a >
bbbababaaaaaba -> a

# < a,b | bbbababaaaabaa=a >
bbbababaaaabaa -> a

# < a,b | bbbababaaaabba=a >
bbbababaaaabba -> a

# < a,b | bbbababaaabaaa=a >
bbbababaaabaaa -> a

# < a,b | bbbababaaababa=a >
bbbababaaababa -> a

# < a,b | bbbababaaabbaa=a >
bbbababaaabbaa -> a

# < a,b | bbbababaaabbba=a >
bbbababaaabbba -> a
bbbababaaaa -> ababaaabbba

# < a,b | bbbababaabaaaa=a >
bbbababaabaaaa -> a

# < a,b | bbbababaabaaba=a >
bbbababaabaaba -> a

# < a,b | bbbababaababaa=a >
bbbababaababaa -> a

# < a,b | bbbababaababba=a >
bbbababaababba -> a

# < a,b | bbbababaabbaaa=a >
bbbababaabbaaa -> a

# < a,b | bbbababaabbaba=a >
bbbababaabbaba -> a

# < a,b | bbbababaabbbaa=a >
bbbababaabbbaa -> a

# < a,b | bbbababaabbbba=a >
bbbababaabbbba -> a
bbbababaaba -> ababaabbbba

# < a,b | bbbabababaaaaa=a >
bbbabababaaaaa -> a

# < a,b | bbbabababaaaba=a >
bbbabababaaaba -> a

# < a,b | bbbabababaabaa=a >
bbbabababaabaa -> a

# < a,b | bbbabababaabba=a >
bbbabababaabba -> a

# < a,b | bbbababababaaa=a >
bbbababababaaa -> a

# < a,b | bbbabababababa=a >
bbbabababababa -> a

# < a,b | bbbababababbaa=a >
bbbababababbaa -> a

# < a,b | bbbababababbba=a >
bbbababababbba -> a
bbbabababaa -> ababababbba

# < a,b | bbbabababbaaaa=a >
bbbabababbaaaa -> a

# < a,b | bbbabababbaaba=a >
bbbabababbaaba -> a

# < a,b | bbbabababbabaa=a >
bbbabababbabaa -> a

# < a,b | bbbabababbabba=a >
bbbabababbabba -> a

# < a,b | bbbabababbbaaa=a >
bbbabababbbaaa -> a

# < a,b | bbbabababbbaba=a >
bbbabababbbaba -> a
bbbababaa -> ababbbaba

# < a,b | bbbabababbbbaa=a >
bbbabababbbbaa -> a

# < a,b | bbbabababbbbba=a >
bbbabababbbbba -> a
bbbabababba -> abababbbbba

# < a,b | bbbababbaaaaaa=a >
bbbababbaaaaaa -> a

# < a,b | bbbababbaaaaba=a >
bbbababbaaaaba -> a

# < a,b | bbbababbaaabaa=a >
bbbababbaaabaa -> a

# < a,b | bbbababbaaabba=a >
bbbababbaaabba -> a

# < a,b | bbbababbaabaaa=a >
bbbababbaabaaa -> a

# < a,b | bbbababbaababa=a >
bbbababbaababa -> a

# < a,b | bbbababbaabbaa=a >
bbbababbaabbaa -> a

# < a,b | bbbababbaabbba=a >
bbbababbaabbba -> a
bbbababbaaa -> ababbaabbba

# < a,b | bbbababbabaaaa=a >
bbbababbabaaaa -> a

# < a,b | bbbababbabaaba=a >
bbbababbabaaba -> a

# < a,b | bbbababbababaa=a >
bbbababbababaa -> a

# < a,b | bbbababbababba=a >
bbbababbababba -> a

# < a,b | bbbababbabbaaa=a >
bbbababbabbaaa -> a

# < a,b | bbbababbabbaba=a >
bbbababbabbaba -> a

# < a,b | bbbababbabbbaa=a >
bbbababbabbbaa -> a

# < a,b | bbbababbabbbba=a >
bbbababbabbbba -> a
bbbababbaba -> ababbabbbba

# < a,b | bbbababbbaaaaa=a >
bbbababbbaaaaa -> a

# < a,b | bbbababbbaaaba=a >
bbbababbbaaaba -> a

# < a,b | bbbababbbaabaa=a >
bbbababbbaabaa -> a

# < a,b | bbbababbbaabba=a >
bbbababbbaabba -> a

# < a,b | bbbababbbabaaa=a >
bbbababbbabaaa -> a

# < a,b | bbbababbbababa=a >
bbbababbbababa -> a

# < a,b | bbbababbbabbaa=a >
bbbababbbabbaa -> a

# < a,b | bbbababbbabbba=a >
bbbababbbabbba -> a
bbbababbbaa -> ababbbabbba

# < a,b | bbbababbbbaaaa=a >
bbbababbbbaaaa -> a

# < a,b | bbbababbbbaaba=a >
bbbababbbbaaba -> a

# < a,b | bbbababbbbabaa=a >
bbbababbbbabaa -> a

# < a,b | bbbababbbbabba=a >
bbbababbbbabba -> a

# < a,b | bbbababbbbbaaa=a >
bbbababbbbbaaa -> a

# < a,b | bbbababbbbbaba=a >
bbbababbbbbaba -> a
bbbababba -> abbbbbaba

# < a,b | bbbababbbbbbaa=a >
bbbababbbbbbaa -> a

# < a,b | bbbababbbbbbba=a >
bbbababbbbbbba -> a
bbbababbbba -> ababbbbbbba
bbbababa -> ababbbba

# < a,b | bbbabbaaaaaaaa=a >
bbbabbaaaaaaaa -> a

# < a,b | bbbabbaaaaaaba=a >
bbbabbaaaaaaba -> a

# < a,b | bbbabbaaaaabaa=a >
bbbabbaaaaabaa -> a

# < a,b | bbbabbaaaaabba=a >
bbbabbaaaaabba -> a

# < a,b | bbbabbaaaabaaa=a >
bbbabbaaaabaaa -> a

# < a,b | bbbabbaaaababa=a >
bbbabbaaaababa -> a

# < a,b | bbbabbaaaabbaa=a >
bbbabbaaaabbaa -> a

# < a,b | bbbabbaaaabbba=a >
bbbabbaaaabbba -> a
bbbabbaaaaa -> abbaaaabbba

# < a,b | bbbabbaaabaaaa=a >
bbbabbaaabaaaa -> a

# < a,b | bbbabbaaabaaba=a >
bbbabbaaabaaba -> a

# < a,b | bbbabbaaababaa=a >
bbbabbaaababaa -> a

# < a,b | bbbabbaaababba=a >
bbbabbaaababba -> a

# < a,b | bbbabbaaabbaaa=a >
bbbabbaaabbaaa -> a

# < a,b | bbbabbaaabbaba=a >
bbbabbaaabbaba -> a

# < a,b | bbbabbaaabbbaa=a >
bbbabbaaabbbaa -> a

# < a,b | bbbabbaaabbbba=a >
bbbabbaaabbbba -> a
bbbabbaaaba -> abbaaabbbba

# < a,b | bbbabbaabaaaaa=a >
bbbabbaabaaaaa -> a

# < a,b | bbbabbaabaaaba=a >
bbbabbaabaaaba -> a

# < a,b | bbbabbaabaabaa=a >
bbbabbaabaabaa -> a

# < a,b | bbbabbaabaabba=a >
bbbabbaabaabba -> a

# < a,b | bbbabbaababaaa=a >
bbbabbaababaaa -> a

# < a,b | bbbabbaabababa=a >
bbbabbaabababa -> a

# < a,b | bbbabbaababbaa=a >
bbbabbaababbaa -> a

# < a,b | bbbabbaababbba=a >
bbbabbaababbba -> a
bbbabbaabaa -> abbaababbba

# < a,b | bbbabbaabbaaaa=a >
bbbabbaabbaaaa -> a

# < a,b | bbbabbaabbaaba=a >
bbbabbaabbaaba -> a

# < a,b | bbbabbaabbabaa=a >
bbbabbaabbabaa -> a

# < a,b | bbbabbaabbabba=a >
bbbabbaabbabba -> a

# < a,b | bbbabbaabbbaaa=a >
bbbabbaabbbaaa -> a

# < a,b | bbbabbaabbbaba=a >
bbbabbaabbbaba -> a

# < a,b | bbbabbaabbbbaa=a >
bbbabbaabbbbaa -> a

# < a,b | bbbabbaabbbbba=a >
bbbabbaabbbbba -> a
bbbabbaabba -> abbaabbbbba

# < a,b | bbbabbabaaaaaa=a >
bbbabbabaaaaaa -> a

# < a,b | bbbabbabaaaaba=a >
bbbabbabaaaaba -> a

# < a,b | bbbabbabaaabaa=a >
bbbabbabaaabaa -> a

# < a,b | bbbabbabaaabba=a >
bbbabbabaaabba -> a

# < a,b | bbbabbabaabaaa=a >
bbbabbabaabaaa -> a

# < a,b | bbbabbabaababa=a >
bbbabbabaababa -> a

# < a,b | bbbabbabaabbaa=a >
bbbabbabaabbaa -> a

# < a,b | bbbabbabaabbba=a >
bbbabbabaabbba -> a
bbbabbabaaa -> abbabaabbba

# < a,b | bbbabbababaaaa=a >
bbbabbababaaaa -> a

# < a,b | bbbabbababaaba=a >
bbbabbababaaba -> a

# < a,b | bbbabbabababaa=a >
bbbabbabababaa -> a

# < a,b | bbbabbabababba=a >
bbbabbabababba -> a

# < a,b | bbbabbababbaaa=a >
bbbabbababbaaa -> a

# < a,b | bbbabbababbaba=a >
bbbabbababbaba -> a

# < a,b | bbbabbababbbaa=a >
bbbabbababbbaa -> a

# < a,b | bbbabbababbbba=a >
bbbabbababbbba -> a
bbbabbababa -> abbababbbba

# < a,b | bbbabbabbaaaaa=a >
bbbabbabbaaaaa -> a

# < a,b | bbbabbabbaaaba=a >
bbbabbabbaaaba -> a

# < a,b | bbbabbabbaabaa=a >
bbbabbabbaabaa -> a

# < a,b | bbbabbabbaabba=a >
bbbabbabbaabba -> a

# < a,b | bbbabbabbabaaa=a >
bbbabbabbabaaa -> a

# < a,b | bbbabbabbababa=a >
bbbabbabbababa -> a

# < a,b | bbbabbabbabbaa=a >
bbbabbabbabbaa -> a

# < a,b | bbbabbabbabbba=a >
bbbabbabbabbba -> a
bbbabbabbaa -> abbabbabbba

# < a,b | bbbabbabbbaaaa=a >
bbbabbabbbaaaa -> a

# < a,b | bbbabbabbbaaba=a >
bbbabbabbbaaba -> a

# < a,b | bbbabbabbbabaa=a >
bbbabbabbbabaa -> a

# < a,b | bbbabbabbbabba=a >
bbbabbabbbabba -> a
bbbabbaa -> abbbabba

# < a,b | bbbabbabbbbaaa=a >
bbbabbabbbbaaa -> a

# < a,b | bbbabbabbbbaba=a >
bbbabbabbbbaba -> a

# < a,b | bbbabbabbbbbaa=a >
bbbabbabbbbbaa -> a

# < a,b | bbbabbabbbbbba=a >
bbbabbabbbbbba -> a
bbbabbabbba -> abbabbbbbba
bbbabbaa -> abbabbba

# < a,b | bbbabbbaaaaaaa=a >
bbbabbbaaaaaaa -> a

# < a,b | bbbabbbaaaaaba=a >
bbbabbbaaaaaba -> a

# < a,b | bbbabbbaaaabaa=a >
bbbabbbaaaabaa -> a

# < a,b | bbbabbbaaaabba=a >
bbbabbbaaaabba -> a

# < a,b | bbbabbbaaabaaa=a >
bbbabbbaaabaaa -> a

# < a,b | bbbabbbaaababa=a >
bbbabbbaaababa -> a

# < a,b | bbbabbbaaabbaa=a >
bbbabbbaaabbaa -> a

# < a,b | bbbabbbaaabbba=a >
bbbabbbaaabbba -> a
bbbabbbaaaa -> abbbaaabbba

# < a,b | bbbabbbaabaaaa=a >
bbbabbbaabaaaa -> a

# < a,b | bbbabbbaabaaba=a >
bbbabbbaabaaba -> a

# < a,b | bbbabbbaababaa=a >
bbbabbbaababaa -> a

# < a,b | bbbabbbaababba=a >
bbbabbbaababba -> a

# < a,b | bbbabbbaabbaaa=a >
bbbabbbaabbaaa -> a

# < a,b | bbbabbbaabbaba=a >
bbbabbbaabbaba -> a

# < a,b | bbbabbbaabbbaa=a >
bbbabbbaabbbaa -> a

# < a,b | bbbabbbaabbbba=a >
bbbabbbaabbbba -> a
bbbabbbaaba -> abbbaabbbba

# < a,b | bbbabbbabaaaaa=a >
bbbabbbabaaaaa -> a

# < a,b | bbbabbbabaaaba=a >
bbbabbbabaaaba -> a

# < a,b | bbbabbbabaabaa=a >
bbbabbbabaabaa -> a

# < a,b | bbbabbbabaabba=a >
bbbabbbabaabba -> a

# < a,b | bbbabbbababaaa=a >
bbbabbbababaaa -> a

# < a,b | bbbabbbabababa=a >
bbbabbbabababa -> a

# < a,b | bbbabbbababbaa=a >
bbbabbbababbaa -> a

# < a,b | bbbabbbababbba=a >
bbbabbbababbba -> a
bbbabbbabaa -> abbbababbba

# < a,b | bbbabbbabbaaaa=a >
bbbabbbabbaaaa -> a

# < a,b | bbbabbbabbaaba=a >
bbbabbbabbaaba -> a

# < a,b | bbbabbbabbabaa=a >
bbbabbbabbabaa -> a

# < a,b | bbbabbbabbabba=a >
bbbabbbabbabba -> a

# < a,b | bbbabbbabbbaaa=a >
bbbabbbabbbaaa -> a

# < a,b | bbbabbbabbbaba=a >
bbbabbbabbbaba -> a

# < a,b | bbbabbbabbbbaa=a >
bbbabbbabbbbaa -> a

# < a,b | bbbabbbabbbbba=a >
bbbabbbabbbbba -> a
bbbabbbabba -> abbbabbbbba

# < a,b | bbbabbbbaaaaaa=a >
bbbabbbbaaaaaa -> a

# < a,b | bbbabbbbaaaaba=a >
bbbabbbbaaaaba -> a

# < a,b | bbbabbbbaaabaa=a >
bbbabbbbaaabaa -> a

# < a,b | bbbabbbbaaabba=a >
bbbabbbbaaabba -> a

# < a,b | bbbabbbbaabaaa=a >
bbbabbbbaabaaa -> a

# < a,b | bbbabbbbaababa=a >
bbbabbbbaababa -> a

# < a,b | bbbabbbbaabbaa=a >
bbbabbbbaabbaa -> a

# < a,b | bbbabbbbaabbba=a >
bbbabbbbaabbba -> a
bbbabbbbaaa -> abbbbaabbba

# < a,b | bbbabbbbabaaaa=a >
bbbabbbbabaaaa -> a

# < a,b | bbbabbbbabaaba=a >
bbbabbbbabaaba -> a

# < a,b | bbbabbbbababaa=a >
bbbabbbbababaa -> a

# < a,b | bbbabbbbababba=a >
bbbabbbbababba -> a

# < a,b | bbbabbbbabbaaa=a >
bbbabbbbabbaaa -> a

# < a,b | bbbabbbbabbaba=a >
bbbabbbbabbaba -> a

# < a,b | bbbabbbbabbbaa=a >
bbbabbbbabbbaa -> a

# < a,b | bbbabbbbabbbba=a >
bbbabbbbabbbba -> a
bbbaba -> abbbba

# < a,b | bbbabbbbbaaaaa=a >
bbbabbbbbaaaaa -> a

# < a,b | bbbabbbbbaaaba=a >
bbbabbbbbaaaba -> a

# < a,b | bbbabbbbbaabaa=a >
bbbabbbbbaabaa -> a

# < a,b | bbbabbbbbaabba=a >
bbbabbbbbaabba -> a

# < a,b | bbbabbbbbabaaa=a >
bbbabbbbbabaaa -> a

# < a,b | bbbabbbbbababa=a >
bbbabbbbbababa -> a

# < a,b | bbbabbbbbabbaa=a >
bbbabbbbbabbaa -> a

# < a,b | bbbabbbbbabbba=a >
bbbabbbbbabbba -> a
bbbabbbbbaa -> abbbbbabbba

# < a,b | bbbabbbbbbaaaa=a >
bbbabbbbbbaaaa -> a

# < a,b | bbbabbbbbbaaba=a >
bbbabbbbbbaaba -> a

# < a,b | bbbabbbbbbabaa=a >
bbbabbbbbbabaa -> a

# < a,b | bbbabbbbbbabba=a >
bbbabbbbbbabba -> a

# < a,b | bbbabbbbbbbaaa=a >
bbbabbbbbbbaaa -> a

# < a,b | bbbabbbbbbbaba=a >
bbbabbbbbbbaba -> a

# < a,b | bbbabbbbbbbbaa=a >
bbbabbbbbbbbaa -> a

# < a,b | bbbabbbbbbbbba=a >
bbbabbbbbbbbba -> a
bbbabbbbbba -> abbbbbbbbba
bbbabbba -> abbbbbba
bbbaa -> abbba

# < a,b | bbbbaaaaaaaaaa=a >
bbbbaaaaaaaaaa -> a

# < a,b | bbbbaaaaaaaaba=a >
bbbbaaaaaaaaba -> a

# < a,b | bbbbaaaaaaabaa=a >
bbbbaaaaaaabaa -> a

# < a,b | bbbbaaaaaaabba=a >
bbbbaaaaaaabba -> a

# < a,b | bbbbaaaaaabaaa=a >
bbbbaaaaaabaaa -> a

# < a,b | bbbbaaaaaababa=a >
bbbbaaaaaababa -> a

# < a,b | bbbbaaaaaabbaa=a >
bbbbaaaaaabbaa -> a

# < a,b | bbbbaaaaaabbba=a >
bbbbaaaaaabbba -> a

# < a,b | bbbbaaaaabaaaa=a >
bbbbaaaaabaaaa -> a

# < a,b | bbbbaaaaabaaba=a >
bbbbaaaaabaaba -> a

# < a,b | bbbbaaaaababaa=a >
bbbbaaaaababaa -> a

# < a,b | bbbbaaaaababba=a >
bbbbaaaaababba -> a

# < a,b | bbbbaaaaabbaaa=a >
bbbbaaaaabbaaa -> a

# < a,b | bbbbaaaaabbaba=a >
bbbbaaaaabbaba -> a

# < a,b | bbbbaaaaabbbaa=a >
bbbbaaaaabbbaa -> a

# < a,b | bbbbaaaaabbbba=a >
bbbbaaaaabbbba -> a
bbbbaaaaaa -> aaaaabbbba

# < a,b | bbbbaaaabaaaaa=a >
bbbbaaaabaaaaa -> a

# < a,b | bbbbaaaabaaaba=a >
bbbbaaaabaaaba -> a

# < a,b | bbbbaaaabaabaa=a >
bbbbaaaabaabaa -> a

# < a,b | bbbbaaaabaabba=a >
bbbbaaaabaabba -> a

# < a,b | bbbbaaaababaaa=a >
bbbbaaaababaaa -> a

# < a,b | bbbbaaaabababa=a >
bbbbaaaabababa -> a

# < a,b | bbbbaaaababbaa=a >
bbbbaaaababbaa -> a

# < a,b | bbbbaaaababbba=a >
bbbbaaaababbba -> a

# < a,b | bbbbaaaabbaaaa=a >
bbbbaaaabbaaaa -> a

# < a,b | bbbbaaaabbaaba=a >
bbbbaaaabbaaba -> a

# < a,b | bbbbaaaabbabaa=a >
bbbbaaaabbabaa -> a

# < a,b | bbbbaaaabbabba=a >
bbbbaaaabbabba -> a

# < a,b | bbbbaaaabbbaaa=a >
bbbbaaaabbbaaa -> a

# < a,b | bbbbaaaabbbaba=a >
bbbbaaaabbbaba -> a

# < a,b | bbbbaaaabbbbaa=a >
bbbbaaaabbbbaa -> a
bbbbaaaaa -> aaabbbbaa

# < a,b | bbbbaaaabbbbba=a >
bbbbaaaabbbbba -> a
bbbbaaaaba -> aaaabbbbba

# < a,b | bbbbaaabaaaaaa=a >
bbbbaaabaaaaaa -> a

# < a,b | bbbbaaabaaaaba=a >
bbbbaaabaaaaba -> a

# < a,b | bbbbaaabaaabaa=a >
bbbbaaabaaabaa -> a

# < a,b | bbbbaaabaaabba=a >
bbbbaaabaaabba -> a

# < a,b | bbbbaaabaabaaa=a >
bbbbaaabaabaaa -> a

# < a,b | bbbbaaabaababa=a >
bbbbaaabaababa -> a

# < a,b | bbbbaaabaabbaa=a >
bbbbaaabaabbaa -> a

# < a,b | bbbbaaabaabbba=a >
bbbbaaabaabbba -> a

# < a,b | bbbbaaababaaaa=a >
bbbbaaababaaaa -> a

# < a,b | bbbbaaababaaba=a >
bbbbaaababaaba -> a

# < a,b | bbbbaaabababaa=a >
bbbbaaabababaa -> a

# < a,b | bbbbaaabababba=a >
bbbbaaabababba -> a

# < a,b | bbbbaaababbaaa=a >
bbbbaaababbaaa -> a

# < a,b | bbbbaaababbaba=a >
bbbbaaababbaba -> a

# < a,b | bbbbaaababbbaa=a >
bbbbaaababbbaa -> a

# < a,b | bbbbaaababbbba=a >
bbbbaaababbbba -> a
bbbbaaabaa -> aaababbbba

# < a,b | bbbbaaabbaaaaa=a >
bbbbaaabbaaaaa -> a

# < a,b | bbbbaaabbaaaba=a >
bbbbaaabbaaaba -> a

# < a,b | bbbbaaabbaabaa=a >
bbbbaaabbaabaa -> a

# < a,b | bbbbaaabbaabba=a >
bbbbaaabbaabba -> a

# < a,b | bbbbaaabbabaaa=a >
bbbbaaabbabaaa -> a

# < a,b | bbbbaaabbababa=a >
bbbbaaabbababa -> a

# < a,b | bbbbaaabbabbaa=a >
bbbbaaabbabbaa -> a

# < a,b | bbbbaaabbabbba=a >
bbbbaaabbabbba -> a

# < a,b | bbbbaaabbbaaaa=a >
bbbbaaabbbaaaa -> a

# < a,b | bbbbaaabbbaaba=a >
bbbbaaabbbaaba -> a

# < a,b | bbbbaaabbbabaa=a >
bbbbaaabbbabaa -> a

# < a,b | bbbbaaabbbabba=a >
bbbbaaabbbabba -> a

# < a,b | bbbbaaabbbbaaa=a >
bbbbaaabbbbaaa -> a
bbbbaaaa -> abbbbaaa

# < a,b | bbbbaaabbbbaba=a >
bbbbaaabbbbaba -> a

# < a,b | bbbbaaabbbbbaa=a >
bbbbaaabbbbbaa -> a
bbbbaaaba -> aabbbbbaa

# < a,b | bbbbaaabbbbbba=a >
bbbbaaabbbbbba -> a
bbbbaaabba -> aaabbbbbba

# < a,b | bbbbaabaaaaaaa=a >
bbbbaabaaaaaaa -> a

# < a,b | bbbbaabaaaaaba=a >
bbbbaabaaaaaba -> a

# < a,b | bbbbaabaaaabaa=a >
bbbbaabaaaabaa -> a

# < a,b | bbbbaabaaaabba=a >
bbbbaabaaaabba -> a

# < a,b | bbbbaabaaabaaa=a >
bbbbaabaaabaaa -> a

# < a,b | bbbbaabaaababa=a >
bbbbaabaaababa -> a

# < a,b | bbbbaabaaabbaa=a >
bbbbaabaaabbaa -> a

# < a,b | bbbbaabaaabbba=a >
bbbbaabaaabbba -> a

# < a,b | bbbbaabaabaaaa=a >
bbbbaabaabaaaa -> a

# < a,b | bbbbaabaabaaba=a >
bbbbaabaabaaba -> a

# < a,b | bbbbaabaababaa=a >
bbbbaabaababaa -> a

# < a,b | bbbbaabaababba=a >
bbbbaabaababba -> a

# < a,b | bbbbaabaabbaaa=a >
bbbbaabaabbaaa -> a

# < a,b | bbbbaabaabbaba=a >
bbbbaabaabbaba -> a

# < a,b | bbbbaabaabbbaa=a >
bbbbaabaabbbaa -> a

# < a,b | bbbbaabaabbbba=a >
bbbbaabaabbbba -> a
bbbbaabaaa -> aabaabbbba

# < a,b | bbbbaababaaaaa=a >
bbbbaababaaaaa -> a

# < a,b | bbbbaababaaaba=a >
bbbbaababaaaba -> a

# < a,b | bbbbaababaabaa=a >
bbbbaababaabaa -> a

# < a,b | bbbbaababaabba=a >
bbbbaababaabba -> a

# < a,b | bbbbaabababaaa=a >
bbbbaabababaaa -> a

# < a,b | bbbbaababababa=a >
bbbbaababababa -> a

# < a,b | bbbbaabababbaa=a >
bbbbaabababbaa -> a

# < a,b | bbbbaabababbba=a >
bbbbaabababbba -> a

# < a,b | bbbbaababbaaaa=a >
bbbbaababbaaaa -> a

# < a,b | bbbbaababbaaba=a >
bbbbaababbaaba -> a

# < a,b | bbbbaababbabaa=a >
bbbbaababbabaa -> a

# < a,b | bbbbaababbabba=a >
bbbbaababbabba -> a

# < a,b | bbbbaababbbaaa=a >
bbbbaababbbaaa -> a

# < a,b | bbbbaababbbaba=a >
bbbbaababbbaba -> a

# < a,b | bbbbaababbbbaa=a >
bbbbaababbbbaa -> a
bbbbaabaa -> ababbbbaa

# < a,b | bbbbaababbbbba=a >
bbbbaababbbbba -> a
bbbbaababa -> aababbbbba

# < a,b | bbbbaabbaaaaaa=a >
bbbbaabbaaaaaa -> a

# < a,b | bbbbaabbaaaaba=a >
bbbbaabbaaaaba -> a

# < a,b | bbbbaabbaaabaa=a >
bbbbaabbaaabaa -> a

# < a,b | bbbbaabbaaabba=a >
bbbbaabbaaabba -> a

# < a,b | bbbbaabbaabaaa=a >
bbbbaabbaabaaa -> a

# < a,b | bbbbaabbaababa=a >
bbbbaabbaababa -> a

# < a,b | bbbbaabbaabbaa=a >
bbbbaabbaabbaa -> a

# < a,b | bbbbaabbaabbba=a >
bbbbaabbaabbba -> a

# < a,b | bbbbaabbabaaaa=a >
bbbbaabbabaaaa -> a

# < a,b | bbbbaabbabaaba=a >
bbbbaabbabaaba -> a

# < a,b | bbbbaabbababaa=a >
bbbbaabbababaa -> a

# < a,b | bbbbaabbababba=a >
bbbbaabbababba -> a

# < a,b | bbbbaabbabbaaa=a >
bbbbaabbabbaaa -> a

# < a,b | bbbbaabbabbaba=a >
bbbbaabbabbaba -> a

# < a,b | bbbbaabbabbbaa=a >
bbbbaabbabbbaa -> a

# < a,b | bbbbaabbabbbba=a >
bbbbaabbabbbba -> a
bbbbaabbaa -> aabbabbbba

# < a,b | bbbbaabbbaaaaa=a >
bbbbaabbbaaaaa -> a

# < a,b | bbbbaabbbaaaba=a >
bbbbaabbbaaaba -> a

# < a,b | bbbbaabbbaabaa=a >
bbbbaabbbaabaa -> a

# < a,b | bbbbaabbbaabba=a >
bbbbaabbbaabba -> a

# < a,b | bbbbaabbbabaaa=a >
bbbbaabbbabaaa -> a

# < a,b | bbbbaabbbababa=a >
bbbbaabbbababa -> a

# < a,b | bbbbaabbbabbaa=a >
bbbbaabbbabbaa -> a

# < a,b | bbbbaabbbabbba=a >
bbbbaabbbabbba -> a

# < a,b | bbbbaabbbbaaaa=a >
bbbbaabbbbaaaa -> a

# < a,b | bbbbaabbbbaaba=a >
bbbbaabbbbaaba -> a

# < a,b | bbbbaabbbbabaa=a >
bbbbaabbbbabaa -> a

# < a,b | bbbbaabbbbabba=a >
bbbbaabbbbabba -> a

# < a,b | bbbbaabbbbbaaa=a >
bbbbaabbbbbaaa -> a

# < a,b | bbbbaabbbbbaba=a >
bbbbaabbbbbaba -> a

# < a,b | bbbbaabbbbbbaa=a >
bbbbaabbbbbbaa -> a
bbbbaabba -> abbbbbbaa

# < a,b | bbbbaabbbbbbba=a >
bbbbaabbbbbbba -> a
bbbbaabbba -> aabbbbbbba

# < a,b | bbbbabaaaaaaaa=a >
bbbbabaaaaaaaa -> a

# < a,b | bbbbabaaaaaaba=a >
bbbbabaaaaaaba -> a

# < a,b | bbbbabaaaaabaa=a >
bbbbabaaaaabaa -> a

# < a,b | bbbbabaaaaabba=a >
bbbbabaaaaabba -> a

# < a,b | bbbbabaaaabaaa=a >
bbbbabaaaabaaa -> a

# < a,b | bbbbabaaaababa=a >
bbbbabaaaababa -> a

# < a,b | bbbbabaaaabbaa=a >
bbbbabaaaabbaa -> a

# < a,b | bbbbabaaaabbba=a >
bbbbabaaaabbba -> a

# < a,b | bbbbabaaabaaaa=a >
bbbbabaaabaaaa -> a

# < a,b | bbbbabaaabaaba=a >
bbbbabaaabaaba -> a

# < a,b | bbbbabaaababaa=a >
bbbbabaaababaa -> a

# < a,b | bbbbabaaababba=a >
bbbbabaaababba -> a

# < a,b | bbbbabaaabbaaa=a >
bbbbabaaabbaaa -> a

# < a,b | bbbbabaaabbaba=a >
bbbbabaaabbaba -> a

# < a,b | bbbbabaaabbbaa=a >
bbbbabaaabbbaa -> a

# < a,b | bbbbabaaabbbba=a >
bbbbabaaabbbba -> a
bbbbabaaaa -> abaaabbbba

# < a,b | bbbbabaabaaaaa=a >
bbbbabaabaaaaa -> a

# < a,b | bbbbabaabaaaba=a >
bbbbabaabaaaba -> a

# < a,b | bbbbabaabaabaa=a >
bbbbabaabaabaa -> a

# < a,b | bbbbabaabaabba=a >
bbbbabaabaabba -> a

# < a,b | bbbbabaababaaa=a >
bbbbabaababaaa -> a

# < a,b | bbbbabaabababa=a >
bbbbabaabababa -> a

# < a,b | bbbbabaababbaa=a >
bbbbabaababbaa -> a

# < a,b | bbbbabaababbba=a >
bbbbabaababbba -> a

# < a,b | bbbbabaabbaaaa=a >
bbbbabaabbaaaa -> a

# < a,b | bbbbabaabbaaba=a >
bbbbabaabbaaba -> a

# < a,b | bbbbabaabbabaa=a >
bbbbabaabbabaa -> a

# < a,b | bbbbabaabbabba=a >
bbbbabaabbabba -> a

# < a,b | bbbbabaabbbaaa=a >
bbbbabaabbbaaa -> a

# < a,b | bbbbabaabbbaba=a >
bbbbabaabbbaba -> a

# < a,b | bbbbabaabbbbaa=a >
bbbbabaabbbbaa -> a

# < a,b | bbbbabaabbbbba=a >
bbbbabaabbbbba -> a
bbbbabaaba -> abaabbbbba

# < a,b | bbbbababaaaaaa=a >
bbbbababaaaaaa -> a

# < a,b | bbbbababaaaaba=a >
bbbbababaaaaba -> a

# < a,b | bbbbababaaabaa=a >
bbbbababaaabaa -> a

# < a,b | bbbbababaaabba=a >
bbbbababaaabba -> a

# < a,b | bbbbababaabaaa=a >
bbbbababaabaaa -> a

# < a,b | bbbbababaababa=a >
bbbbababaababa -> a

# < a,b | bbbbababaabbaa=a >
bbbbababaabbaa -> a

# < a,b | bbbbababaabbba=a >
bbbbababaabbba -> a

# < a,b | bbbbabababaaaa=a >
bbbbabababaaaa -> a

# < a,b | bbbbabababaaba=a >
bbbbabababaaba -> a

# < a,b | bbbbababababaa=a >
bbbbababababaa -> a

# < a,b | bbbbababababba=a >
bbbbababababba -> a

# < a,b | bbbbabababbaaa=a >
bbbbabababbaaa -> a

# < a,b | bbbbabababbaba=a >
bbbbabababbaba -> a

# < a,b | bbbbabababbbaa=a >
bbbbabababbbaa -> a

# < a,b | bbbbabababbbba=a >
bbbbabababbbba -> a
bbbbababaa -> abababbbba

# < a,b | bbbbababbaaaaa=a >
bbbbababbaaaaa -> a

# < a,b | bbbbababbaaaba=a >
bbbbababbaaaba -> a

# < a,b | bbbbababbaabaa=a >
bbbbababbaabaa -> a

# < a,b | bbbbababbaabba=a >
bbbbababbaabba -> a

# < a,b | bbbbababbabaaa=a >
bbbbababbabaaa -> a

# < a,b | bbbbababbababa=a >
bbbbababbababa -> a

# < a,b | bbbbababbabbaa=a >
bbbbababbabbaa -> a

# < a,b | bbbbababbabbba=a >
bbbbababbabbba -> a

# < a,b | bbbbababbbaaaa=a >
bbbbababbbaaaa -> a

# < a,b | bbbbababbbaaba=a >
bbbbababbbaaba -> a

# < a,b | bbbbababbbabaa=a >
bbbbababbbabaa -> a

# < a,b | bbbbababbbabba=a >
bbbbababbbabba -> a

# < a,b | bbbbababbbbaaa=a >
bbbbababbbbaaa -> a

# < a,b | bbbbababbbbaba=a >
bbbbababbbbaba -> a
bbbbabaa -> abbbbaba

# < a,b | bbbbababbbbbaa=a >
bbbbababbbbbaa -> a

# < a,b | bbbbababbbbbba=a >
bbbbababbbbbba -> a
bbbbababba -> ababbbbbba

# < a,b | bbbbabbaaaaaaa=a >
bbbbabbaaaaaaa -> a

# < a,b | bbbbabbaaaaaba=a >
bbbbabbaaaaaba -> a

# < a,b | bbbbabbaaaabaa=a >
bbbbabbaaaabaa -> a

# < a,b | bbbbabbaaaabba=a >
bbbbabbaaaabba -> a

# < a,b | bbbbabbaaabaaa=a >
bbbbabbaaabaaa -> a

# < a,b | bbbbabbaaababa=a >
bbbbabbaaababa -> a

# < a,b | bbbbabbaaabbaa=a >
bbbbabbaaabbaa -> a

# < a,b | bbbbabbaaabbba=a >
bbbbabbaaabbba -> a

# < a,b | bbbbabbaabaaaa=a >
bbbbabbaabaaaa -> a

# < a,b | bbbbabbaabaaba=a >
bbbbabbaabaaba -> a

# < a,b | bbbbabbaababaa=a >
bbbbabbaababaa -> a

# < a,b | bbbbabbaababba=a >
bbbbabbaababba -> a

# < a,b | bbbbabbaabbaaa=a >
bbbbabbaabbaaa -> a

# < a,b | bbbbabbaabbaba=a >
bbbbabbaabbaba -> a

# < a,b | bbbbabbaabbbaa=a >
bbbbabbaabbbaa -> a

# < a,b | bbbbabbaabbbba=a >
bbbbabbaabbbba -> a
bbbbabbaaa -> abbaabbbba

# < a,b | bbbbabbabaaaaa=a >
bbbbabbabaaaaa -> a

# < a,b | bbbbabbabaaaba=a >
bbbbabbabaaaba -> a

# < a,b | bbbbabbabaabaa=a >
bbbbabbabaabaa -> a

# < a,b | bbbbabbabaabba=a >
bbbbabbabaabba -> a

# < a,b | bbbbabbababaaa=a >
bbbbabbababaaa -> a

# < a,b | bbbbabbabababa=a >
bbbbabbabababa -> a

# < a,b | bbbbabbababbaa=a >
bbbbabbababbaa -> a

# < a,b | bbbbabbababbba=a >
bbbbabbababbba -> a

# < a,b | bbbbabbabbaaaa=a >
bbbbabbabbaaaa -> a

# < a,b | bbbbabbabbaaba=a >
bbbbabbabbaaba -> a

# < a,b | bbbbabbabbabaa=a >
bbbbabbabbabaa -> a

# < a,b | bbbbabbabbabba=a >
bbbbabbabbabba -> a

# < a,b | bbbbabbabbbaaa=a >
bbbbabbabbbaaa -> a

# < a,b | bbbbabbabbbaba=a >
bbbbabbabbbaba -> a

# < a,b | bbbbabbabbbbaa=a >
bbbbabbabbbbaa -> a

# < a,b | bbbbabbabbbbba=a >
bbbbabbabbbbba -> a
bbbbabbaba -> abbabbbbba

# < a,b | bbbbabbbaaaaaa=a >
bbbbabbbaaaaaa -> a

# < a,b | bbbbabbbaaaaba=a >
bbbbabbbaaaaba -> a

# < a,b | bbbbabbbaaabaa=a >
bbbbabbbaaabaa -> a

# < a,b | bbbbabbbaaabba=a >
bbbbabbbaaabba -> a

# < a,b | bbbbabbbaabaaa=a >
bbbbabbbaabaaa -> a

# < a,b | bbbbabbbaababa=a >
bbbbabbbaababa -> a

# < a,b | bbbbabbbaabbaa=a >
bbbbabbbaabbaa -> a

# < a,b | bbbbabbbaabbba=a >
bbbbabbbaabbba -> a

# < a,b | bbbbabbbabaaaa=a >
bbbbabbbabaaaa -> a

# < a,b | bbbbabbbabaaba=a >
bbbbabbbabaaba -> a

# < a,b | bbbbabbbababaa=a >
bbbbabbbababaa -> a

# < a,b | bbbbabbbababba=a >
bbbbabbbababba -> a

# < a,b | bbbbabbbabbaaa=a >
bbbbabbbabbaaa -> a

# < a,b | bbbbabbbabbaba=a >
bbbbabbbabbaba -> a

# < a,b | bbbbabbbabbbaa=a >
bbbbabbbabbbaa -> a

# < a,b | bbbbabbbabbbba=a >
bbbbabbbabbbba -> a
bbbbabbbaa -> abbbabbbba

# < a,b | bbbbabbbbaaaaa=a >
bbbbabbbbaaaaa -> a

# < a,b | bbbbabbbbaaaba=a >
bbbbabbbbaaaba -> a

# < a,b | bbbbabbbbaabaa=a >
bbbbabbbbaabaa -> a

# < a,b | bbbbabbbbaabba=a >
bbbbabbbbaabba -> a

# < a,b | bbbbabbbbabaaa=a >
bbbbabbbbabaaa -> a

# < a,b | bbbbabbbbababa=a >
bbbbabbbbababa -> a

# < a,b | bbbbabbbbabbaa=a >
bbbbabbbbabbaa -> a

# < a,b | bbbbabbbbabbba=a >
bbbbabbbbabbba -> a

# < a,b | bbbbabbbbbaaaa=a >
bbbbabbbbbaaaa -> a

# < a,b | bbbbabbbbbaaba=a >
bbbbabbbbbaaba -> a

# < a,b | bbbbabbbbbabaa=a >
bbbbabbbbbabaa -> a

# < a,b | bbbbabbbbbabba=a >
bbbbabbbbbabba -> a

# < a,b | bbbbabbbbbbaaa=a >
bbbbabbbbbbaaa -> a

# < a,b | bbbbabbbbbbaba=a >
bbbbabbbbbbaba -> a

# < a,b | bbbbabbbbbbbaa=a >
bbbbabbbbbbbaa -> a

# < a,b | bbbbabbbbbbbba=a >
bbbbabbbbbbbba -> a
bbbbabbbba -> abbbbbbbba
bbbbaa -> abbbba

# < a,b | bbbbbaaaaaaaaa=a >
bbbbbaaaaaaaaa -> a

# < a,b | bbbbbaaaaaaaba=a >
bbbbbaaaaaaaba -> a

# < a,b | bbbbbaaaaaabaa=a >
bbbbbaaaaaabaa -> a

# < a,b | bbbbbaaaaaabba=a >
bbbbbaaaaaabba -> a

# < a,b | bbbbbaaaaabaaa=a >
bbbbbaaaaabaaa -> a

# < a,b | bbbbbaaaaababa=a >
bbbbbaaaaababa -> a

# < a,b | bbbbbaaaaabbaa=a >
bbbbbaaaaabbaa -> a

# < a,b | bbbbbaaaaabbba=a >
bbbbbaaaaabbba -> a

# < a,b | bbbbbaaaabaaaa=a >
bbbbbaaaabaaaa -> a

# < a,b | bbbbbaaaabaaba=a >
bbbbbaaaabaaba -> a

# < a,b | bbbbbaaaababaa=a >
bbbbbaaaababaa -> a

# < a,b | bbbbbaaaababba=a >
bbbbbaaaababba -> a

# < a,b | bbbbbaaaabbaaa=a >
bbbbbaaaabbaaa -> a

# < a,b | bbbbbaaaabbaba=a >
bbbbbaaaabbaba -> a

# < a,b | bbbbbaaaabbbaa=a >
bbbbbaaaabbbaa -> a

# < a,b | bbbbbaaaabbbba=a >
bbbbbaaaabbbba -> a

# < a,b | bbbbbaaabaaaaa=a >
bbbbbaaabaaaaa -> a

# < a,b | bbbbbaaabaaaba=a >
bbbbbaaabaaaba -> a

# < a,b | bbbbbaaabaabaa=a >
bbbbbaaabaabaa -> a

# < a,b | bbbbbaaabaabba=a >
bbbbbaaabaabba -> a

# < a,b | bbbbbaaababaaa=a >
bbbbbaaababaaa -> a

# < a,b | bbbbbaaabababa=a >
bbbbbaaabababa -> a

# < a,b | bbbbbaaababbaa=a >
bbbbbaaababbaa -> a

# < a,b | bbbbbaaababbba=a >
bbbbbaaababbba -> a

# < a,b | bbbbbaaabbaaaa=a >
bbbbbaaabbaaaa -> a

# < a,b | bbbbbaaabbaaba=a >
bbbbbaaabbaaba -> a

# < a,b | bbbbbaaabbabaa=a >
bbbbbaaabbabaa -> a

# < a,b | bbbbbaaabbabba=a >
bbbbbaaabbabba -> a

# < a,b | bbbbbaaabbbaaa=a >
bbbbbaaabbbaaa -> a

# < a,b | bbbbbaaabbbaba=a >
bbbbbaaabbbaba -> a

# < a,b | bbbbbaaabbbbaa=a >
bbbbbaaabbbbaa -> a

# < a,b | bbbbbaaabbbbba=a >
bbbbbaaabbbbba -> a
bbbbbaaaa -> aaabbbbba

# < a,b | bbbbbaabaaaaaa=a >
bbbbbaabaaaaaa -> a

# < a,b | bbbbbaabaaaaba=a >
bbbbbaabaaaaba -> a

# < a,b | bbbbbaabaaabaa=a >
bbbbbaabaaabaa -> a

# < a,b | bbbbbaabaaabba=a >
bbbbbaabaaabba -> a

# < a,b | bbbbbaabaabaaa=a >
bbbbbaabaabaaa -> a

# < a,b | bbbbbaabaababa=a >
bbbbbaabaababa -> a

# < a,b | bbbbbaabaabbaa=a >
bbbbbaabaabbaa -> a

# < a,b | bbbbbaabaabbba=a >
bbbbbaabaabbba -> a

# < a,b | bbbbbaababaaaa=a >
bbbbbaababaaaa -> a

# < a,b | bbbbbaababaaba=a >
bbbbbaababaaba -> a

# < a,b | bbbbbaabababaa=a >
bbbbbaabababaa -> a

# < a,b | bbbbbaabababba=a >
bbbbbaabababba -> a

# < a,b | bbbbbaababbaaa=a >
bbbbbaababbaaa -> a

# < a,b | bbbbbaababbaba=a >
bbbbbaababbaba -> a

# < a,b | bbbbbaababbbaa=a >
bbbbbaababbbaa -> a

# < a,b | bbbbbaababbbba=a >
bbbbbaababbbba -> a

# < a,b | bbbbbaabbaaaaa=a >
bbbbbaabbaaaaa -> a

# < a,b | bbbbbaabbaaaba=a >
bbbbbaabbaaaba -> a

# < a,b | bbbbbaabbaabaa=a >
bbbbbaabbaabaa -> a

# < a,b | bbbbbaabbaabba=a >
bbbbbaabbaabba -> a

# < a,b | bbbbbaabbabaaa=a >
bbbbbaabbabaaa -> a

# < a,b | bbbbbaabbababa=a >
bbbbbaabbababa -> a

# < a,b | bbbbbaabbabbaa=a >
bbbbbaabbabbaa -> a

# < a,b | bbbbbaabbabbba=a >
bbbbbaabbabbba -> a

# < a,b | bbbbbaabbbaaaa=a >
bbbbbaabbbaaaa -> a

# < a,b | bbbbbaabbbaaba=a >
bbbbbaabbbaaba -> a

# < a,b | bbbbbaabbbabaa=a >
bbbbbaabbbabaa -> a

# < a,b | bbbbbaabbbabba=a >
bbbbbaabbbabba -> a

# < a,b | bbbbbaabbbbaaa=a >
bbbbbaabbbbaaa -> a

# < a,b | bbbbbaabbbbaba=a >
bbbbbaabbbbaba -> a

# < a,b | bbbbbaabbbbbaa=a >
bbbbbaabbbbbaa -> a
bbbbbaaa -> abbbbbaa

# < a,b | bbbbbaabbbbbba=a >
bbbbbaabbbbbba -> a
bbbbbaaba -> aabbbbbba

# < a,b | bbbbbabaaaaaaa=a >
bbbbbabaaaaaaa -> a

# < a,b | bbbbbabaaaaaba=a >
bbbbbabaaaaaba -> a

# < a,b | bbbbbabaaaabaa=a >
bbbbbabaaaabaa -> a

# < a,b | bbbbbabaaaabba=a >
bbbbbabaaaabba -> a

# < a,b | bbbbbabaaabaaa=a >
bbbbbabaaabaaa -> a

# < a,b | bbbbbabaaababa=a >
bbbbbabaaababa -> a

# < a,b | bbbbbabaaabbaa=a >
bbbbbabaaabbaa -> a

# < a,b | bbbbbabaaabbba=a >
bbbbbabaaabbba -> a

# < a,b | bbbbbabaabaaaa=a >
bbbbbabaabaaaa -> a

# < a,b | bbbbbabaabaaba=a >
bbbbbabaabaaba -> a

# < a,b | bbbbbabaababaa=a >
bbbbbabaababaa -> a

# < a,b | bbbbbabaababba=a >
bbbbbabaababba -> a

# < a,b | bbbbbabaabbaaa=a >
bbbbbabaabbaaa -> a

# < a,b | bbbbbabaabbaba=a >
bbbbbabaabbaba -> a

# < a,b | bbbbbabaabbbaa=a >
bbbbbabaabbbaa -> a

# < a,b | bbbbbabaabbbba=a >
bbbbbabaabbbba -> a

# < a,b | bbbbbababaaaaa=a >
bbbbbababaaaaa -> a

# < a,b | bbbbbababaaaba=a >
bbbbbababaaaba -> a

# < a,b | bbbbbababaabaa=a >
bbbbbababaabaa -> a

# < a,b | bbbbbababaabba=a >
bbbbbababaabba -> a

# < a,b | bbbbbabababaaa=a >
bbbbbabababaaa -> a

# < a,b | bbbbbababababa=a >
bbbbbababababa -> a

# < a,b | bbbbbabababbaa=a >
bbbbbabababbaa -> a

# < a,b | bbbbbabababbba=a >
bbbbbabababbba -> a

# < a,b | bbbbbababbaaaa=a >
bbbbbababbaaaa -> a

# < a,b | bbbbbababbaaba=a >
bbbbbababbaaba -> a

# < a,b | bbbbbababbabaa=a >
bbbbbababbabaa -> a

# < a,b | bbbbbababbabba=a >
bbbbbababbabba -> a

# < a,b | bbbbbababbbaaa=a >
bbbbbababbbaaa -> a

# < a,b | bbbbbababbbaba=a >
bbbbbababbbaba -> a

# < a,b | bbbbbababbbbaa=a >
bbbbbababbbbaa -> a

# < a,b | bbbbbababbbbba=a >
bbbbbababbbbba -> a
bbbbbabaa -> ababbbbba

# < a,b | bbbbbabbaaaaaa=a >
bbbbbabbaaaaaa -> a

# < a,b | bbbbbabbaaaaba=a >
bbbbbabbaaaaba -> a

# < a,b | bbbbbabbaaabaa=a >
bbbbbabbaaabaa -> a

# < a,b | bbbbbabbaaabba=a >
bbbbbabbaaabba -> a

# < a,b | bbbbbabbaabaaa=a >
bbbbbabbaabaaa -> a

# < a,b | bbbbbabbaababa=a >
bbbbbabbaababa -> a

# < a,b | bbbbbabbaabbaa=a >
bbbbbabbaabbaa -> a

# < a,b | bbbbbabbaabbba=a >
bbbbbabbaabbba -> a

# < a,b | bbbbbabbabaaaa=a >
bbbbbabbabaaaa -> a

# < a,b | bbbbbabbabaaba=a >
bbbbbabbabaaba -> a

# < a,b | bbbbbabbababaa=a >
bbbbbabbababaa -> a

# < a,b | bbbbbabbababba=a >
bbbbbabbababba -> a

# < a,b | bbbbbabbabbaaa=a >
bbbbbabbabbaaa -> a

# < a,b | bbbbbabbabbaba=a >
bbbbbabbabbaba -> a

# < a,b | bbbbbabbabbbaa=a >
bbbbbabbabbbaa -> a

# < a,b | bbbbbabbabbbba=a >
bbbbbabbabbbba -> a

# < a,b | bbbbbabbbaaaaa=a >
bbbbbabbbaaaaa -> a

# < a,b | bbbbbabbbaaaba=a >
bbbbbabbbaaaba -> a

# < a,b | bbbbbabbbaabaa=a >
bbbbbabbbaabaa -> a

# < a,b | bbbbbabbbaabba=a >
bbbbbabbbaabba -> a

# < a,b | bbbbbabbbabaaa=a >
bbbbbabbbabaaa -> a

# < a,b | bbbbbabbbababa=a >
bbbbbabbbababa -> a

# < a,b | bbbbbabbbabbaa=a >
bbbbbabbbabbaa -> a

# < a,b | bbbbbabbbabbba=a >
bbbbbabbbabbba -> a

# < a,b | bbbbbabbbbaaaa=a >
bbbbbabbbbaaaa -> a

# < a,b | bbbbbabbbbaaba=a >
bbbbbabbbbaaba -> a

# < a,b | bbbbbabbbbabaa=a >
bbbbbabbbbabaa -> a

# < a,b | bbbbbabbbbabba=a >
bbbbbabbbbabba -> a

# < a,b | bbbbbabbbbbaaa=a >
bbbbbabbbbbaaa -> a

# < a,b | bbbbbabbbbbaba=a >
bbbbbabbbbbaba -> a

# < a,b | bbbbbabbbbbbaa=a >
bbbbbabbbbbbaa -> a

# < a,b | bbbbbabbbbbbba=a >
bbbbbabbbbbbba -> a
bbbbbabba -> abbbbbbba

# < a,b | bbbbbbaaaaaaaa=a >
bbbbbbaaaaaaaa -> a

# < a,b | bbbbbbaaaaaaba=a >
bbbbbbaaaaaaba -> a

# < a,b | bbbbbbaaaaabaa=a >
bbbbbbaaaaabaa -> a

# < a,b | bbbbbbaaaaabba=a >
bbbbbbaaaaabba -> a

# < a,b | bbbbbbaaaabaaa=a >
bbbbbbaaaabaaa -> a

# < a,b | bbbbbbaaaababa=a >
bbbbbbaaaababa -> a

# < a,b | bbbbbbaaaabbaa=a >
bbbbbbaaaabbaa -> a

# < a,b | bbbbbbaaaabbba=a >
bbbbbbaaaabbba -> a

# < a,b | bbbbbbaaabaaaa=a >
bbbbbbaaabaaaa -> a

# < a,b | bbbbbbaaabaaba=a >
bbbbbbaaabaaba -> a

# < a,b | bbbbbbaaababaa=a >
bbbbbbaaababaa -> a

# < a,b | bbbbbbaaababba=a >
bbbbbbaaababba -> a

# < a,b | bbbbbbaaabbaaa=a >
bbbbbbaaabbaaa -> a

# < a,b | bbbbbbaaabbaba=a >
bbbbbbaaabbaba -> a

# < a,b | bbbbbbaaabbbaa=a >
bbbbbbaaabbbaa -> a

# < a,b | bbbbbbaaabbbba=a >
bbbbbbaaabbbba -> a

# < a,b | bbbbbbaabaaaaa=a >
bbbbbbaabaaaaa -> a

# < a,b | bbbbbbaabaaaba=a >
bbbbbbaabaaaba -> a

# < a,b | bbbbbbaabaabaa=a >
bbbbbbaabaabaa -> a

# < a,b | bbbbbbaabaabba=a >
bbbbbbaabaabba -> a

# < a,b | bbbbbbaababaaa=a >
bbbbbbaababaaa -> a

# < a,b | bbbbbbaabababa=a >
bbbbbbaabababa -> a

# < a,b | bbbbbbaababbaa=a >
bbbbbbaababbaa -> a

# < a,b | bbbbbbaababbba=a >
bbbbbbaababbba -> a

# < a,b | bbbbbbaabbaaaa=a >
bbbbbbaabbaaaa -> a

# < a,b | bbbbbbaabbaaba=a >
bbbbbbaabbaaba -> a

# < a,b | bbbbbbaabbabaa=a >
bbbbbbaabbabaa -> a

# < a,b | bbbbbbaabbabba=a >
bbbbbbaabbabba -> a

# < a,b | bbbbbbaabbbaaa=a >
bbbbbbaabbbaaa -> a

# < a,b | bbbbbbaabbbaba=a >
bbbbbbaabbbaba -> a

# < a,b | bbbbbbaabbbbaa=a >
bbbbbbaabbbbaa -> a

# < a,b | bbbbbbaabbbbba=a >
bbbbbbaabbbbba -> a

# < a,b | bbbbbbabaaaaaa=a >
bbbbbbabaaaaaa -> a

# < a,b | bbbbbbabaaaaba=a >
bbbbbbabaaaaba -> a

# < a,b | bbbbbbabaaabaa=a >
bbbbbbabaaabaa -> a

# < a,b | bbbbbbabaaabba=a >
bbbbbbabaaabba -> a

# < a,b | bbbbbbabaabaaa=a >
bbbbbbabaabaaa -> a

# < a,b | bbbbbbabaababa=a >
bbbbbbabaababa -> a

# < a,b | bbbbbbabaabbaa=a >
bbbbbbabaabbaa -> a

# < a,b | bbbbbbabaabbba=a >
bbbbbbabaabbba -> a

# < a,b | bbbbbbababaaaa=a >
bbbbbbababaaaa -> a

# < a,b | bbbbbbababaaba=a >
bbbbbbababaaba -> a

# < a,b | bbbbbbabababaa=a >
bbbbbbabababaa -> a

# < a,b | bbbbbbabababba=a >
bbbbbbabababba -> a

# < a,b | bbbbbbababbaaa=a >
bbbbbbababbaaa -> a

# < a,b | bbbbbbababbaba=a >
bbbbbbababbaba -> a

# < a,b | bbbbbbababbbaa=a >
bbbbbbababbbaa -> a

# < a,b | bbbbbbababbbba=a >
bbbbbbababbbba -> a

# < a,b | bbbbbbabbaaaaa=a >
bbbbbbabbaaaaa -> a

# < a,b | bbbbbbabbaaaba=a >
bbbbbbabbaaaba -> a

# < a,b | bbbbbbabbaabaa=a >
bbbbbbabbaabaa -> a

# < a,b | bbbbbbabbaabba=a >
bbbbbbabbaabba -> a

# < a,b | bbbbbbabbabaaa=a >
bbbbbbabbabaaa -> a

# < a,b | bbbbbbabbababa=a >
bbbbbbabbababa -> a

# < a,b | bbbbbbabbabbaa=a >
bbbbbbabbabbaa -> a

# < a,b | bbbbbbabbabbba=a >
bbbbbbabbabbba -> a

# < a,b | bbbbbbabbbaaaa=a >
bbbbbbabbbaaaa -> a

# < a,b | bbbbbbabbbaaba=a >
bbbbbbabbbaaba -> a

# < a,b | bbbbbbabbbabaa=a >
bbbbbbabbbabaa -> a

# < a,b | bbbbbbabbbabba=a >
bbbbbbabbbabba -> a

# < a,b | bbbbbbabbbbaaa=a >
bbbbbbabbbbaaa -> a

# < a,b | bbbbbbabbbbaba=a >
bbbbbbabbbbaba -> a

# < a,b | bbbbbbabbbbbaa=a >
bbbbbbabbbbbaa -> a

# < a,b | bbbbbbabbbbbba=a >
bbbbbbabbbbbba -> a
bbbbbbaa -> abbbbbba

# < a,b | bbbbbbbaaaaaaa=a >
bbbbbbbaaaaaaa -> a

# < a,b | bbbbbbbaaaaaba=a >
bbbbbbbaaaaaba -> a

# < a,b | bbbbbbbaaaabaa=a >
bbbbbbbaaaabaa -> a

# < a,b | bbbbbbbaaaabba=a >
bbbbbbbaaaabba -> a

# < a,b | bbbbbbbaaabaaa=a >
bbbbbbbaaabaaa -> a

# < a,b | bbbbbbbaaababa=a >
bbbbbbbaaababa -> a

# < a,b | bbbbbbbaaabbaa=a >
bbbbbbbaaabbaa -> a

# < a,b | bbbbbbbaaabbba=a >
bbbbbbbaaabbba -> a

# < a,b | bbbbbbbaabaaaa=a >
bbbbbbbaabaaaa -> a

# < a,b | bbbbbbbaabaaba=a >
bbbbbbbaabaaba -> a

# < a,b | bbbbbbbaababaa=a >
bbbbbbbaababaa -> a

# < a,b | bbbbbbbaababba=a >
bbbbbbbaababba -> a

# < a,b | bbbbbbbaabbaaa=a >
bbbbbbbaabbaaa -> a

# < a,b | bbbbbbbaabbaba=a >
bbbbbbbaabbaba -> a

# < a,b | bbbbbbbaabbbaa=a >
bbbbbbbaabbbaa -> a

# < a,b | bbbbbbbaabbbba=a >
bbbbbbbaabbbba -> a

# < a,b | bbbbbbbabaaaaa=a >
bbbbbbbabaaaaa -> a

# < a,b | bbbbbbbabaaaba=a >
bbbbbbbabaaaba -> a

# < a,b | bbbbbbbabaabaa=a >
bbbbbbbabaabaa -> a

# < a,b | bbbbbbbabaabba=a >
bbbbbbbabaabba -> a

# < a,b | bbbbbbbababaaa=a >
bbbbbbbababaaa -> a

# < a,b | bbbbbbbabababa=a >
bbbbbbbabababa -> a

# < a,b | bbbbbbbababbaa=a >
bbbbbbbababbaa -> a

# < a,b | bbbbbbbababbba=a >
bbbbbbbababbba -> a

# < a,b | bbbbbbbabbaaaa=a >
bbbbbbbabbaaaa -> a

# < a,b | bbbbbbbabbaaba=a >
bbbbbbbabbaaba -> a

# < a,b | bbbbbbbabbabaa=a >
bbbbbbbabbabaa -> a

# < a,b | bbbbbbbabbabba=a >
bbbbbbbabbabba -> a

# < a,b | bbbbbbbabbbaaa=a >
bbbbbbbabbbaaa -> a

# < a,b | bbbbbbbabbbaba=a >
bbbbbbbabbbaba -> a

# < a,b | bbbbbbbabbbbaa=a >
bbbbbbbabbbbaa -> a

# < a,b | bbbbbbbabbbbba=a >
bbbbbbbabbbbba -> a

# < a,b | bbbbbbbbaaaaaa=a >
bbbbbbbbaaaaaa -> a

# < a,b | bbbbbbbbaaaaba=a >
bbbbbbbbaaaaba -> a

# < a,b | bbbbbbbbaaabaa=a >
bbbbbbbbaaabaa -> a

# < a,b | bbbbbbbbaaabba=a >
bbbbbbbbaaabba -> a

# < a,b | bbbbbbbbaabaaa=a >
bbbbbbbbaabaaa -> a

# < a,b | bbbbbbbbaababa=a >
bbbbbbbbaababa -> a

# < a,b | bbbbbbbbaabbaa=a >
bbbbbbbbaabbaa -> a

# < a,b | bbbbbbbbaabbba=a >
bbbbbbbbaabbba -> a

# < a,b | bbbbbbbbabaaaa=a >
bbbbbbbbabaaaa -> a

# < a,b | bbbbbbbbabaaba=a >
bbbbbbbbabaaba -> a

# < a,b | bbbbbbbbababaa=a >
bbbbbbbbababaa -> a

# < a,b | bbbbbbbbababba=a >
bbbbbbbbababba -> a

# < a,b | bbbbbbbbabbaaa=a >
bbbbbbbbabbaaa -> a

# < a,b | bbbbbbbbabbaba=a >
bbbbbbbbabbaba -> a

# < a,b | bbbbbbbbabbbaa=a >
bbbbbbbbabbbaa -> a

# < a,b | bbbbbbbbabbbba=a >
bbbbbbbbabbbba -> a

# < a,b | bbbbbbbbbaaaaa=a >
bbbbbbbbbaaaaa -> a

# < a,b | bbbbbbbbbaaaba=a >
bbbbbbbbbaaaba -> a

# < a,b | bbbbbbbbbaabaa=a >
bbbbbbbbbaabaa -> a

# < a,b | bbbbbbbbbaabba=a >
bbbbbbbbbaabba -> a

# < a,b | bbbbbbbbbabaaa=a >
bbbbbbbbbabaaa -> a

# < a,b | bbbbbbbbbababa=a >
bbbbbbbbbababa -> a

# < a,b | bbbbbbbbbabbaa=a >
bbbbbbbbbabbaa -> a

# < a,b | bbbbbbbbbabbba=a >
bbbbbbbbbabbba -> a

# < a,b | bbbbbbbbbbaaaa=a >
bbbbbbbbbbaaaa -> a

# < a,b | bbbbbbbbbbaaba=a >
bbbbbbbbbbaaba -> a

# < a,b | bbbbbbbbbbabaa=a >
bbbbbbbbbbabaa -> a

# < a,b | bbbbbbbbbbabba=a >
bbbbbbbbbbabba -> a

# < a,b | bbbbbbbbbbbaaa=a >
bbbbbbbbbbbaaa -> a

# < a,b | bbbbbbbbbbbaba=a >
bbbbbbbbbbbaba -> a

# < a,b | bbbbbbbbbbbbaa=a >
bbbbbbbbbbbbaa -> a

# < a,b | bbbbbbbbbbbbba=a >
bbbbbbbbbbbbba -> a

# < a,b | baaaaaaaaaaaaaa=a >
baaaaaaaaaaaaaa -> a

# < a,b | baaaaaaaaaaaaba=a >
baaaaaaaaaaaaba -> a
baaaaaaaaaaaaa -> aaaaaaaaaaaaba

# < a,b | baaaaaaaaaaabaa=a >
baaaaaaaaaaabaa -> a
baaaaaaaaaaaa -> aaaaaaaaaabaa

# < a,b | baaaaaaaaaaabba=a >
baaaaaaaaaaabba -> a
baaaaaaaaaaaba -> aaaaaaaaaaabba
baaaaaaaaaaaa -> aaaaaaaaaaaba

# < a,b | baaaaaaaaaabaaa=a >
baaaaaaaaaabaaa -> a
baaaaaaaaaaa -> aaaaaaaabaaa

# < a,b | baaaaaaaaaabbba=a >
baaaaaaaaaabbba -> a
baaaaaaaaaabba -> aaaaaaaaaabbba
baaaaaaaaaaba -> aaaaaaaaaabba
baaaaaaaaaaa -> aaaaaaaaaaba

# < a,b | baaaaaaaaabaaaa=a >
baaaaaaaaabaaaa -> a
baaaaaaaaaa -> aaaaaabaaaa

# < a,b | baaaaaaaaababaa=a >
baaaaaaaaababaa -> a
baaaaaaaaabaa -> aaaaaaaababaa
baaaaaaaaaa -> aaaaaaaabaa

# < a,b | baaaaaaaaabbbba=a >
baaaaaaaaabbbba -> a
baaaaaaaaabbba -> aaaaaaaaabbbba
baaaaaaaaabba -> aaaaaaaaabbba
baaaaaaaaaba -> aaaaaaaaabba
baaaaaaaaaa -> aaaaaaaaaba

# < a,b | baaaaaaaabaaaaa=a >
baaaaaaaabaaaaa -> a
baaaaaaaaa -> aaaabaaaaa

# < a,b | baaaaaaaabbbbba=a >
baaaaaaaabbbbba -> a
baaaaaaaabbbba -> aaaaaaaabbbbba
baaaaaaaabbba -> aaaaaaaabbbba
baaaaaaaabba -> aaaaaaaabbba
baaaaaaaaba -> aaaaaaaabba
baaaaaaaaa -> aaaaaaaaba

# < a,b | baaaaaaabaaaaaa=a >
baaaaaaabaaaaaa -> a
baaaaaaaa -> aabaaaaaa

# < a,b | baaaaaaabaabaaa=a >
baaaaaaabaabaaa -> a
baaaaaaabaaa -> aaaaabaabaaa
baaaaaaaa -> aaaaabaaa

# < a,b | baaaaaaabababaa=a >
baaaaaaabababaa -> a
baaaaaaababaa -> aaaaaabababaa
baaaaaaabaa -> aaaaaababaa
baaaaaaaa -> aaaaaabaa

# < a,b | baaaaaaabbbbbba=a >
baaaaaaabbbbbba -> a
baaaaaaabbbbba -> aaaaaaabbbbbba
baaaaaaabbbba -> aaaaaaabbbbba
baaaaaaabbba -> aaaaaaabbbba
baaaaaaabba -> aaaaaaabbba
baaaaaaaba -> aaaaaaabba
baaaaaaaa -> aaaaaaaba

# < a,b | baaaaaabaaaaaaa=a >
baaaaaabaaaaaaa -> a

# < a,b | baaaaaabbbbbbba=a >
baaaaaabbbbbbba -> a
baaaaaabbbbbba -> aaaaaabbbbbbba
baaaaaabbbbba -> aaaaaabbbbbba
baaaaaabbbba -> aaaaaabbbbba
baaaaaabbba -> aaaaaabbbba
baaaaaabba -> aaaaaabbba
baaaaaaba -> aaaaaabba
baaaaaaa -> aaaaaaba

# < a,b | baaaaabaaaaaaaa=a >
baaaaabaaaaaaaa -> a

# < a,b | baaaaabaaaaaaba=a >
baaaaabaaaaaaba -> a
baaaaabaaaaaaa -> aaaaabaaaaaaba

# < a,b | baaaaabaaaaabaa=a >
baaaaabaaaaabaa -> a
baaaaaa -> aaaabaa

# < a,b | baaaaabaaabaaaa=a >
baaaaabaaabaaaa -> a
baaaaabaaaa -> aabaaabaaaa
baaaaaa -> aabaaaa

# < a,b | baaaaababaaaaaa=a >
baaaaababaaaaaa -> a

# < a,b | baaaaababababaa=a >
baaaaababababaa -> a
baaaaabababaa -> aaaababababaa
baaaaababaa -> aaaabababaa
baaaaabaa -> aaaababaa
baaaaaa -> aaaabaa

# < a,b | baaaaabbaaaaaaa=a >
baaaaabbaaaaaaa -> a

# < a,b | baaaaabbaaaaaba=a >
baaaaabbaaaaaba -> a
baaaaabbaaaaaa -> aaaaabbaaaaaba

# < a,b | baaaaabbbaaaaaa=a >
baaaaabbbaaaaaa -> a

# < a,b | baaaaabbbbbbbba=a >
baaaaabbbbbbbba -> a
baaaaabbbbbbba -> aaaaabbbbbbbba
baaaaabbbbbba -> aaaaabbbbbbba
baaaaabbbbba -> aaaaabbbbbba
baaaaabbbba -> aaaaabbbbba
baaaaabbba -> aaaaabbbba
baaaaabba -> aaaaabbba
baaaaaba -> aaaaabba
baaaaaa -> aaaaaba

# < a,b | baaaabaaaaaaaaa=a >
baaaabaaaaaaaaa -> a

# < a,b | baaaabaaaaaaaba=a >
baaaabaaaaaaaba -> a
baaaabaaaaaaaa -> aaaabaaaaaaaba

# < a,b | baaaabaaaaaabaa=a >
baaaabaaaaaabaa -> a
baaaabaaaaaaa -> aaabaaaaaabaa

# < a,b | baaaabaaaaaabba=a >
baaaabaaaaaabba -> a
baaaabaaaaaaba -> aaaabaaaaaabba
baaaabaaaaaaa -> aaaabaaaaaaba

# < a,b | baaaabaaaaabaaa=a >
baaaabaaaaabaaa -> a
baaaabaaaaaa -> aabaaaaabaaa

# < a,b | baaaabaaaaabbba=a >
baaaabaaaaabbba -> a
baaaabaaaaabba -> aaaabaaaaabbba
baaaabaaaaaba -> aaaabaaaaabba
baaaabaaaaaa -> aaaabaaaaaba

# < a,b | baaaabaaaabaaaa=a >
baaaabaaaabaaaa -> a
baaaaa -> abaaaa

# < a,b | baaaabaaabaaaaa=a >
baaaabaaabaaaaa -> a

# < a,b | baaaabaabaaaaaa=a >
baaaabaabaaaaaa -> a

# < a,b | baaaabaabaabaaa=a >
baaaabaabaabaaa -> a
baaaabaabaaa -> aabaabaabaaa
baaaabaaa -> aabaabaaa
baaaaa -> aabaaa

# < a,b | baaaabaabbaaaaa=a >
baaaabaabbaaaaa -> a

# < a,b | baaaababaaaaaaa=a >
baaaababaaaaaaa -> a

# < a,b | baaaababaaaaaba=a >
baaaababaaaaaba -> a
baaaababaaaaaa -> aaaababaaaaaba

# < a,b | baaaababaaaabaa=a >
baaaababaaaabaa -> a
baaaababaaaaa -> aaababaaaabaa

# < a,b | baaaabababaaaaa=a >
baaaabababaaaaa -> a

# < a,b | baaaababbaaaaaa=a >
baaaababbaaaaaa -> a

# < a,b | baaaababbbaaaaa=a >
baaaababbbaaaaa -> a

# < a,b | baaaabbaaaaaaaa=a >
baaaabbaaaaaaaa -> a

# < a,b | baaaabbaaaaaaba=a >
baaaabbaaaaaaba -> a
baaaabbaaaaaaa -> aaaabbaaaaaaba

# < a,b | baaaabbaaaaabaa=a >
baaaabbaaaaabaa -> a
baaaabbaaaaaa -> aaabbaaaaabaa

# < a,b | baaaabbaaaaabba=a >
baaaabbaaaaabba -> a
baaaabbaaaaaba -> aaaabbaaaaabba
baaaabbaaaaaa -> aaaabbaaaaaba

# < a,b | baaaabbaaaabaaa=a >
baaaabbaaaabaaa -> a
baaaabbaaaaa -> aabbaaaabaaa

# < a,b | baaaabbaabaaaaa=a >
baaaabbaabaaaaa -> a

# < a,b | baaaabbabaaaaaa=a >
baaaabbabaaaaaa -> a

# < a,b | baaaabbabaaaaba=a >
baaaabbabaaaaba -> a
baaaabbabaaaaa -> aaaabbabaaaaba

# < a,b | baaaabbabbaaaaa=a >
baaaabbabbaaaaa -> a

# < a,b | baaaabbbaaaaaaa=a >
baaaabbbaaaaaaa -> a

# < a,b | baaaabbbaaaaaba=a >
baaaabbbaaaaaba -> a
baaaabbbaaaaaa -> aaaabbbaaaaaba

# < a,b | baaaabbbaaaabaa=a >
baaaabbbaaaabaa -> a
baaaabbbaaaaa -> aaabbbaaaabaa

# < a,b | baaaabbbaaaabba=a >
baaaabbbaaaabba -> a
baaaabbbaaaaba -> aaaabbbaaaabba
baaaabbbaaaaa -> aaaabbbaaaaba

# < a,b | baaaabbbabaaaaa=a >
baaaabbbabaaaaa -> a

# < a,b | baaaabbbbaaaaaa=a >
baaaabbbbaaaaaa -> a

# < a,b | baaaabbbbaaaaba=a >
baaaabbbbaaaaba -> a
baaaabbbbaaaaa -> aaaabbbbaaaaba

# < a,b | baaaabbbbbaaaaa=a >
baaaabbbbbaaaaa -> a

# < a,b | baaaabbbbbbbbba=a >
baaaabbbbbbbbba -> a
baaaabbbbbbbba -> aaaabbbbbbbbba
baaaabbbbbbba -> aaaabbbbbbbba
baaaabbbbbba -> aaaabbbbbbba
baaaabbbbba -> aaaabbbbbba
baaaabbbba -> aaaabbbbba
baaaabbba -> aaaabbbba
baaaabba -> aaaabbba
baaaaba -> aaaabba
baaaaa -> aaaaba

# < a,b | baaabaaaaaaaaaa=a >
baaabaaaaaaaaaa -> a

# < a,b | baaabaaaaaaaaba=a >
baaabaaaaaaaaba -> a
baaabaaaaaaaaa -> aaabaaaaaaaaba

# < a,b | baaabaaaaaaabaa=a >
baaabaaaaaaabaa -> a
baaabaaaaaaaa -> aabaaaaaaabaa

# < a,b | baaabaaaaaaabba=a >
baaabaaaaaaabba -> a
baaabaaaaaaaba -> aaabaaaaaaabba
baaabaaaaaaaa -> aaabaaaaaaaba

# < a,b | baaabaaaaaabaaa=a >
baaabaaaaaabaaa -> a
baaabaaaaaaa -> abaaaaaabaaa

# < a,b | baaabaaaaaabbba=a >
baaabaaaaaabbba -> a
baaabaaaaaabba -> aaabaaaaaabbba
baaabaaaaaaba -> aaabaaaaaabba
baaabaaaaaaa -> aaabaaaaaaba

# < a,b | baaabaaaaabaaaa=a >
baaabaaaaabaaaa -> a

# < a,b | baaabaaaaababaa=a >
baaabaaaaababaa -> a
baaabaaaaabaa -> aabaaaaababaa
baaabaaaaaa -> aabaaaaabaa

# < a,b | baaabaaaaabbbba=a >
baaabaaaaabbbba -> a
baaabaaaaabbba -> aaabaaaaabbbba
baaabaaaaabba -> aaabaaaaabbba
baaabaaaaaba -> aaabaaaaabba
baaabaaaaaa -> aaabaaaaaba

# < a,b | baaabaaaabaaaaa=a >
baaabaaaabaaaaa -> a

# < a,b | baaabaaaabaaaba=a >
baaabaaaabaaaba -> a
baaabaaaabaaaa -> aaabaaaabaaaba
baaabaaaaa -> aaaabaaaba

# < a,b | baaabaaaabbaaaa=a >
baaabaaaabbaaaa -> a

# < a,b | baaabaaaabbbbba=a >
baaabaaaabbbbba -> a
baaabaaaabbbba -> aaabaaaabbbbba
baaabaaaabbba -> aaabaaaabbbba
baaabaaaabba -> aaabaaaabbba
baaabaaaaba -> aaabaaaabba
baaabaaaaa -> aaabaaaaba

# < a,b | baaabaaabaaaaaa=a >
baaabaaabaaaaaa -> a

# < a,b | baaabaaabaaaaba=a >
baaabaaabaaaaba -> a
baaabaaabaaaaa -> aaabaaabaaaaba

# < a,b | baaabaaabaaabaa=a >
baaabaaabaaabaa -> a
baaaa -> aabaa

# < a,b | baaabaaababaaaa=a >
baaabaaababaaaa -> a

# < a,b | baaabaaabbaaaaa=a >
baaabaaabbaaaaa -> a

# < a,b | baaabaaabbaaaba=a >
baaabaaabbaaaba -> a
baaabaaaba -> aaabbaaaba
baaaa -> aaaba

# < a,b | baaabaaabbbaaaa=a >
baaabaaabbbaaaa -> a

# < a,b | baaabaabaaaaaaa=a >
baaabaabaaaaaaa -> a

# < a,b | baaabaabaaaaaba=a >
baaabaabaaaaaba -> a
baaabaabaaaaaa -> aaabaabaaaaaba

# < a,b | baaabaabaaaabaa=a >
baaabaabaaaabaa -> a
baaabaabaaaaa -> aabaabaaaabaa

# < a,b | baaabaabaaaabba=a >
baaabaabaaaabba -> a
baaabaabaaaaba -> aaabaabaaaabba
baaabaabaaaaa -> aaabaabaaaaba

# < a,b | baaabaabaaabaaa=a >
baaabaabaaabaaa -> a
baaabaabaaaa -> abaabaaabaaa

# < a,b | baaabaabaabaaaa=a >
baaabaabaabaaaa -> a

# < a,b | baaabaababaaaaa=a >
baaabaababaaaaa -> a

# < a,b | baaabaababbaaaa=a >
baaabaababbaaaa -> a

# < a,b | baaabaabbaaaaaa=a >
baaabaabbaaaaaa -> a

# < a,b | baaabaabbaaaaba=a >
baaabaabbaaaaba -> a
baaabaabbaaaaa -> aaabaabbaaaaba

# < a,b | baaabaabbabaaaa=a >
baaabaabbabaaaa -> a

# < a,b | baaabaabbbaaaaa=a >
baaabaabbbaaaaa -> a

# < a,b | baaabaabbbbaaaa=a >
baaabaabbbbaaaa -> a

# < a,b | baaababaaaaaaaa=a >
baaababaaaaaaaa -> a

# < a,b | baaababaaaaaaba=a >
baaababaaaaaaba -> a
baaababaaaaaaa -> aaababaaaaaaba

# < a,b | baaababaaaaabaa=a >
baaababaaaaabaa -> a
baaababaaaaaa -> aababaaaaabaa

# < a,b | baaababaaaaabba=a >
baaababaaaaabba -> a
baaababaaaaaba -> aaababaaaaabba
baaababaaaaaa -> aaababaaaaaba

# < a,b | baaababaaaabaaa=a >
baaababaaaabaaa -> a
baaababaaaaa -> ababaaaabaaa

# < a,b | baaababaaaabbba=a >
baaababaaaabbba -> a
baaababaaaabba -> aaababaaaabbba
baaababaaaaba -> aaababaaaabba
baaababaaaaa -> aaababaaaaba

# < a,b | baaababaaabaaaa=a >
baaababaaabaaaa -> a

# < a,b | baaababaaababaa=a >
baaababaaababaa -> a
baaabaa -> aababaa
baaaa -> aabaa

# < a,b | baaababaabaaaaa=a >
baaababaabaaaaa -> a

# < a,b | baaababaabbaaaa=a >
baaababaabbaaaa -> a

# < a,b | baaabababaaaaaa=a >
baaabababaaaaaa -> a

# < a,b | baaabababaaaaba=a >
baaabababaaaaba -> a
baaabababaaaaa -> aaabababaaaaba

# < a,b | baaabababaaabaa=a >
baaabababaaabaa -> a
baaabababaaaa -> aabababaaabaa

# < a,b | baaababababaaaa=a >
baaababababaaaa -> a

# < a,b | baaabababababaa=a >
baaabababababaa -> a
baaababababaa -> aabababababaa
baaabababaa -> aababababaa
baaababaa -> aabababaa
baaabaa -> aababaa
baaaa -> aabaa

# < a,b | baaabababbaaaaa=a >
baaabababbaaaaa -> a

# < a,b | baaabababbbaaaa=a >
baaabababbbaaaa -> a

# < a,b | baaababbaaaaaaa=a >
baaababbaaaaaaa -> a

# < a,b | baaababbaaaaaba=a >
baaababbaaaaaba -> a
baaababbaaaaaa -> aaababbaaaaaba

# < a,b | baaababbaaaabaa=a >
baaababbaaaabaa -> a
baaababbaaaaa -> aababbaaaabaa

# < a,b | baaababbaaaabba=a >
baaababbaaaabba -> a
baaababbaaaaba -> aaababbaaaabba
baaababbaaaaa -> aaababbaaaaba

# < a,b | baaababbaaabaaa=a >
baaababbaaabaaa -> a
baaababbaaaa -> ababbaaabaaa

# < a,b | baaababbaabaaaa=a >
baaababbaabaaaa -> a

# < a,b | baaababbabaaaaa=a >
baaababbabaaaaa -> a

# < a,b | baaababbabbaaaa=a >
baaababbabbaaaa -> a

# < a,b | baaababbbaaaaaa=a >
baaababbbaaaaaa -> a

# < a,b | baaababbbaaaaba=a >
baaababbbaaaaba -> a
baaababbbaaaaa -> aaababbbaaaaba

# < a,b | baaababbbaaabaa=a >
baaababbbaaabaa -> a
baaababbbaaaa -> aababbbaaabaa

# < a,b | baaababbbabaaaa=a >
baaababbbabaaaa -> a

# < a,b | baaababbbbaaaaa=a >
baaababbbbaaaaa -> a

# < a,b | baaababbbbbaaaa=a >
baaababbbbbaaaa -> a

# < a,b | baaabbaaaaaaaaa=a >
baaabbaaaaaaaaa -> a

# < a,b | baaabbaaaaaaaba=a >
baaabbaaaaaaaba -> a
baaabbaaaaaaaa -> aaabbaaaaaaaba

# < a,b | baaabbaaaaaabaa=a >
baaabbaaaaaabaa -> a
baaabbaaaaaaa -> aabbaaaaaabaa

# < a,b | baaabbaaaaaabba=a >
baaabbaaaaaabba -> a
baaabbaaaaaaba -> aaabbaaaaaabba
baaabbaaaaaaa -> aaabbaaaaaaba

# < a,b | baaabbaaaaabaaa=a >
baaabbaaaaabaaa -> a
baaabbaaaaaa -> abbaaaaabaaa

# < a,b | baaabbaaaaabbba=a >
baaabbaaaaabbba -> a
baaabbaaaaabba -> aaabbaaaaabbba
baaabbaaaaaba -> aaabbaaaaabba
baaabbaaaaaa -> aaabbaaaaaba

# < a,b | baaabbaaaabaaaa=a >
baaabbaaaabaaaa -> a

# < a,b | baaabbaaaababaa=a >
baaabbaaaababaa -> a
baaabbaaaabaa -> aabbaaaababaa
baaabbaaaaa -> aabbaaaabaa

# < a,b | baaabbaaaabbbba=a >
baaabbaaaabbbba -> a
baaabbaaaabbba -> aaabbaaaabbbba
baaabbaaaabba -> aaabbaaaabbba
baaabbaaaaba -> aaabbaaaabba
baaabbaaaaa -> aaabbaaaaba

# < a,b | baaabbaaabaaaaa=a >
baaabbaaabaaaaa -> a

# < a,b | baaabbaaabaaaba=a >
baaabbaaabaaaba -> a
baaabbaaabaaaa -> aaabbaaabaaaba

# < a,b | baaabbaaabbaaaa=a >
baaabbaaabbaaaa -> a

# < a,b | baaabbaabaaaaaa=a >
baaabbaabaaaaaa -> a

# < a,b | baaabbaabaaaaba=a >
baaabbaabaaaaba -> a
baaabbaabaaaaa -> aaabbaabaaaaba

# < a,b | baaabbaabaaabaa=a >
baaabbaabaaabaa -> a
baaabbaabaaaa -> aabbaabaaabaa

# < a,b | baaabbaababaaaa=a >
baaabbaababaaaa -> a

# < a,b | baaabbaabbaaaaa=a >
baaabbaabbaaaaa -> a

# < a,b | baaabbaabbaaaba=a >
baaabbaabbaaaba -> a
baaabbaabbaaaa -> aaabbaabbaaaba

# < a,b | baaabbaabbbaaaa=a >
baaabbaabbbaaaa -> a

# < a,b | baaabbabaaaaaaa=a >
baaabbabaaaaaaa -> a

# < a,b | baaabbabaaaaaba=a >
baaabbabaaaaaba -> a
baaabbabaaaaaa -> aaabbabaaaaaba

# < a,b | baaabbabaaaabaa=a >
baaabbabaaaabaa -> a
baaabbabaaaaa -> aabbabaaaabaa

# < a,b | baaabbabaaaabba=a >
baaabbabaaaabba -> a
baaabbabaaaaba -> aaabbabaaaabba
baaabbabaaaaa -> aaabbabaaaaba

# < a,b | baaabbabaaabaaa=a >
baaabbabaaabaaa -> a
baaabbabaaaa -> abbabaaabaaa

# < a,b | baaabbabaabaaaa=a >
baaabbabaabaaaa -> a

# < a,b | baaabbababaaaaa=a >
baaabbababaaaaa -> a

# < a,b | baaabbababaaaba=a >
baaabbababaaaba -> a
baaabbababaaaa -> aaabbababaaaba

# < a,b | baaabbababbaaaa=a >
baaabbababbaaaa -> a

# < a,b | baaabbabbaaaaaa=a >
baaabbabbaaaaaa -> a

# < a,b | baaabbabbaaaaba=a >
baaabbabbaaaaba -> a
baaabbabbaaaaa -> aaabbabbaaaaba

# < a,b | baaabbabbaaabaa=a >
baaabbabbaaabaa -> a
baaabbabbaaaa -> aabbabbaaabaa

# < a,b | baaabbabbabaaaa=a >
baaabbabbabaaaa -> a

# < a,b | baaabbabbbaaaaa=a >
baaabbabbbaaaaa -> a

# < a,b | baaabbabbbaaaba=a >
baaabbabbbaaaba -> a
baaabbabbbaaaa -> aaabbabbbaaaba

# < a,b | baaabbabbbbaaaa=a >
baaabbabbbbaaaa -> a

# < a,b | baaabbbaaaaaaaa=a >
baaabbbaaaaaaaa -> a

# < a,b | baaabbbaaaaaaba=a >
baaabbbaaaaaaba -> a
baaabbbaaaaaaa -> aaabbbaaaaaaba

# < a,b | baaabbbaaaaabaa=a >
baaabbbaaaaabaa -> a
baaabbbaaaaaa -> aabbbaaaaabaa

# < a,b | baaabbbaaaaabba=a >
baaabbbaaaaabba -> a
baaabbbaaaaaba -> aaabbbaaaaabba
baaabbbaaaaaa -> aaabbbaaaaaba

# < a,b | baaabbbaaaabaaa=a >
baaabbbaaaabaaa -> a
baaabbbaaaaa -> abbbaaaabaaa

# < a,b | baaabbbaaaabbba=a >
baaabbbaaaabbba -> a
baaabbbaaaabba -> aaabbbaaaabbba
baaabbbaaaaba -> aaabbbaaaabba
baaabbbaaaaa -> aaabbbaaaaba

# < a,b | baaabbbaaabaaaa=a >
baaabbbaaabaaaa -> a

# < a,b | baaabbbaaababaa=a >
baaabbbaaababaa -> a
baaabbbaaabaa -> aabbbaaababaa
baaabbbaaaa -> aabbbaaabaa

# < a,b | baaabbbaabaaaaa=a >
baaabbbaabaaaaa -> a

# < a,b | baaabbbaabaaaba=a >
baaabbbaabaaaba -> a
baaabbbaabaaaa -> aaabbbaabaaaba

# < a,b | baaabbbaabbaaaa=a >
baaabbbaabbaaaa -> a

# < a,b | baaabbbabaaaaaa=a >
baaabbbabaaaaaa -> a

# < a,b | baaabbbabaaaaba=a >
baaabbbabaaaaba -> a
baaabbbabaaaaa -> aaabbbabaaaaba

# < a,b | baaabbbabaaabaa=a >
baaabbbabaaabaa -> a
baaabbbabaaaa -> aabbbabaaabaa

# < a,b | baaabbbabaaabba=a >
baaabbbabaaabba -> a
baaabbbabaaaba -> aaabbbabaaabba
baaabbbabaaaa -> aaabbbabaaaba

# < a,b | baaabbbababaaaa=a >
baaabbbababaaaa -> a

# < a,b | baaabbbabbaaaaa=a >
baaabbbabbaaaaa -> a

# < a,b | baaabbbabbaaaba=a >
baaabbbabbaaaba -> a
baaabbbabbaaaa -> aaabbbabbaaaba

# < a,b | baaabbbabbbaaaa=a >
baaabbbabbbaaaa -> a

# < a,b | baaabbbbaaaaaaa=a >
baaabbbbaaaaaaa -> a

# < a,b | baaabbbbaaaaaba=a >
baaabbbbaaaaaba -> a
baaabbbbaaaaaa -> aaabbbbaaaaaba

# < a,b | baaabbbbaaaabaa=a >
baaabbbbaaaabaa -> a
baaabbbbaaaaa -> aabbbbaaaabaa

# < a,b | baaabbbbaaaabba=a >
baaabbbbaaaabba -> a
baaabbbbaaaaba -> aaabbbbaaaabba
baaabbbbaaaaa -> aaabbbbaaaaba

# < a,b | baaabbbbaaabaaa=a >
baaabbbbaaabaaa -> a
baaabbbbaaaa -> abbbbaaabaaa

# < a,b | baaabbbbaaabbba=a >
baaabbbbaaabbba -> a
baaabbbbaaabba -> aaabbbbaaabbba
baaabbbbaaaba -> aaabbbbaaabba
baaabbbbaaaa -> aaabbbbaaaba

# < a,b | baaabbbbaabaaaa=a >
baaabbbbaabaaaa -> a

# < a,b | baaabbbbabaaaaa=a >
baaabbbbabaaaaa -> a

# < a,b | baaabbbbabaaaba=a >
baaabbbbabaaaba -> a
baaabbbbabaaaa -> aaabbbbabaaaba

# < a,b | baaabbbbabbaaaa=a >
baaabbbbabbaaaa -> a

# < a,b | baaabbbbbaaaaaa=a >
baaabbbbbaaaaaa -> a

# < a,b | baaabbbbbaaaaba=a >
baaabbbbbaaaaba -> a
baaabbbbbaaaaa -> aaabbbbbaaaaba

# < a,b | baaabbbbbaaabaa=a >
baaabbbbbaaabaa -> a
baaabbbbbaaaa -> aabbbbbaaabaa

# < a,b | baaabbbbbaaabba=a >
baaabbbbbaaabba -> a
baaabbbbbaaaba -> aaabbbbbaaabba
baaabbbbbaaaa -> aaabbbbbaaaba

# < a,b | baaabbbbbabaaaa=a >
baaabbbbbabaaaa -> a

# < a,b | baaabbbbbbaaaaa=a >
baaabbbbbbaaaaa -> a

# < a,b | baaabbbbbbaaaba=a >
baaabbbbbbaaaba -> a
baaabbbbbbaaaa -> aaabbbbbbaaaba

# < a,b | baaabbbbbbbaaaa=a >
baaabbbbbbbaaaa -> a

# < a,b | baaabbbbbbbbbba=a >
baaabbbbbbbbbba -> a
baaabbbbbbbbba -> aaabbbbbbbbbba
baaabbbbbbbba -> aaabbbbbbbbba
baaabbbbbbba -> aaabbbbbbbba
baaabbbbbba -> aaabbbbbbba
baaabbbbba -> aaabbbbbba
baaabbbba -> aaabbbbba
baaabbba -> aaabbbba
baaabba -> aaabbba
baaaba -> aaabba
baaaa -> aaaba

# < a,b | baabaaaaaaaaaaa=a >
baabaaaaaaaaaaa -> a

# < a,b | baabaaaaaaaaaba=a >
baabaaaaaaaaaba -> a
baabaaaaaaaaaa -> aabaaaaaaaaaba

# < a,b | baabaaaaaaaabaa=a >
baabaaaaaaaabaa -> a
baabaaaaaaaaa -> abaaaaaaaabaa

# < a,b | baabaaaaaaaabba=a >
baabaaaaaaaabba -> a
baabaaaaaaaaba -> aabaaaaaaaabba
baabaaaaaaaaa -> aabaaaaaaaaba

# < a,b | baabaaaaaaabaaa=a >
baabaaaaaaabaaa -> a

# < a,b | baabaaaaaaabbba=a >
baabaaaaaaabbba -> a
baabaaaaaaabba -> aabaaaaaaabbba
baabaaaaaaaba -> aabaaaaaaabba
baabaaaaaaaa -> aabaaaaaaaba

# < a,b | baabaaaaaabaaaa=a >
baabaaaaaabaaaa -> a

# < a,b | baabaaaaaabaaba=a >
baabaaaaaabaaba -> a
baabaaaaaabaaa -> aabaaaaaabaaba
baabaaaaaaa -> aaaaaabaaba

# < a,b | baabaaaaaababaa=a >
baabaaaaaababaa -> a
baabaaaaaabaa -> abaaaaaababaa
baabaaaaaaa -> abaaaaaabaa

# < a,b | baabaaaaaabbaaa=a >
baabaaaaaabbaaa -> a

# < a,b | baabaaaaaabbbba=a >
baabaaaaaabbbba -> a
baabaaaaaabbba -> aabaaaaaabbbba
baabaaaaaabba -> aabaaaaaabbba
baabaaaaaaba -> aabaaaaaabba
baabaaaaaaa -> aabaaaaaaba

# < a,b | baabaaaaabaaaaa=a >
baabaaaaabaaaaa -> a

# < a,b | baabaaaaabaaaba=a >
baabaaaaabaaaba -> a
baabaaaaabaaaa -> aabaaaaabaaaba

# < a,b | baabaaaaabaabaa=a >
baabaaaaabaabaa -> a
baabaaaaabaaa -> abaaaaabaabaa
baabaaaaaa -> aaaabaabaa

# < a,b | baabaaaaababaaa=a >
baabaaaaababaaa -> a

# < a,b | baabaaaaabbaaaa=a >
baabaaaaabbaaaa -> a

# < a,b | baabaaaaabbaaba=a >
baabaaaaabbaaba -> a
baabaaaaabbaaa -> aabaaaaabbaaba
baabaaaaaba -> aaaaabbaaba
baabaaaaaa -> aaaaabbaaa

# < a,b | baabaaaaabbbaaa=a >
baabaaaaabbbaaa -> a

# < a,b | baabaaaaabbbbba=a >
baabaaaaabbbbba -> a
baabaaaaabbbba -> aabaaaaabbbbba
baabaaaaabbba -> aabaaaaabbbba
baabaaaaabba -> aabaaaaabbba
baabaaaaaba -> aabaaaaabba
baabaaaaaa -> aabaaaaaba

# < a,b | baabaaaabaaaaaa=a >
baabaaaabaaaaaa -> a

# < a,b | baabaaaabaaaaba=a >
baabaaaabaaaaba -> a
baabaaaabaaaaa -> aabaaaabaaaaba

# < a,b | baabaaaabaaabaa=a >
baabaaaabaaabaa -> a
baabaaaabaaaa -> abaaaabaaabaa

# < a,b | baabaaaabaaabba=a >
baabaaaabaaabba -> a
baabaaaabaaaba -> aabaaaabaaabba
baabaaaabaaaa -> aabaaaabaaaba

# < a,b | baabaaaabaabaaa=a >
baabaaaabaabaaa -> a
baabaaaaa -> aabaabaaa

# < a,b | baabaaaababaaaa=a >
baabaaaababaaaa -> a

# < a,b | baabaaaabababaa=a >
baabaaaabababaa -> a
baabaaaababaa -> abaaaabababaa
baabaaaabaa -> abaaaababaa
baabaaaaa -> abaaaabaa

# < a,b | baabaaaababbaaa=a >
baabaaaababbaaa -> a

# < a,b | baabaaaabbaaaaa=a >
baabaaaabbaaaaa -> a

# < a,b | baabaaaabbaaaba=a >
baabaaaabbaaaba -> a
baabaaaabbaaaa -> aabaaaabbaaaba

# < a,b | baabaaaabbabaaa=a >
baabaaaabbabaaa -> a

# < a,b | baabaaaabbbaaaa=a >
baabaaaabbbaaaa -> a

# < a,b | baabaaaabbbbaaa=a >
baabaaaabbbbaaa -> a

# < a,b | baabaaaabbbbbba=a >
baabaaaabbbbbba -> a
baabaaaabbbbba -> aabaaaabbbbbba
baabaaaabbbba -> aabaaaabbbbba
baabaaaabbba -> aabaaaabbbba
baabaaaabba -> aabaaaabbba
baabaaaaba -> aabaaaabba
baabaaaaa -> aabaaaaba

# < a,b | baabaaabaaaaaaa=a >
baabaaabaaaaaaa -> a

# < a,b | baabaaabaaaaaba=a >
baabaaabaaaaaba -> a
baabaaabaaaaaa -> aabaaabaaaaaba

# < a,b | baabaaabaaaabaa=a >
baabaaabaaaabaa -> a
baabaaabaaaaa -> abaaabaaaabaa

# < a,b | baabaaabaaaabba=a >
baabaaabaaaabba -> a
baabaaabaaaaba -> aabaaabaaaabba
baabaaabaaaaa -> aabaaabaaaaba

# < a,b | baabaaabaaabaaa=a >
baabaaabaaabaaa -> a

# < a,b | baabaaabaaabbba=a >
baabaaabaaabbba -> a
baabaaabaaabba -> aabaaabaaabbba
baabaaabaaaba -> aabaaabaaabba
baabaaabaaaa -> aabaaabaaaba

# < a,b | baabaaabaabaaaa=a >
baabaaabaabaaaa -> a

# < a,b | baabaaabaabbaaa=a >
baabaaabaabbaaa -> a

# < a,b | baabaaababaaaaa=a >
baabaaababaaaaa -> a

# < a,b | baabaaababaaaba=a >
baabaaababaaaba -> a
baabaaababaaaa -> aabaaababaaaba

# < a,b | baabaaababaabaa=a >
baabaaababaabaa -> a
baabaaababaaa -> abaaababaabaa
baabaaabaa -> aababaabaa
baabaaaa -> aababaaa

# < a,b | baabaaabababaaa=a >
baabaaabababaaa -> a

# < a,b | baabaaababbaaaa=a >
baabaaababbaaaa -> a

# < a,b | baabaaababbbaaa=a >
baabaaababbbaaa -> a

# < a,b | baabaaabbaaaaaa=a >
baabaaabbaaaaaa -> a

# < a,b | baabaaabbaaaaba=a >
baabaaabbaaaaba -> a
baabaaabbaaaaa -> aabaaabbaaaaba

# < a,b | baabaaabbaaabaa=a >
baabaaabbaaabaa -> a
baabaaabbaaaa -> abaaabbaaabaa

# < a,b | baabaaabbaaabba=a >
baabaaabbaaabba -> a
baabaaabbaaaba -> aabaaabbaaabba
baabaaabbaaaa -> aabaaabbaaaba

# < a,b | baabaaabbabaaaa=a >
baabaaabbabaaaa -> a

# < a,b | baabaaabbabbaaa=a >
baabaaabbabbaaa -> a

# < a,b | baabaaabbbaaaaa=a >
baabaaabbbaaaaa -> a

# < a,b | baabaaabbbaaaba=a >
baabaaabbbaaaba -> a
baabaaabbbaaaa -> aabaaabbbaaaba

# < a,b | baabaaabbbabaaa=a >
baabaaabbbabaaa -> a

# < a,b | baabaaabbbbaaaa=a >
baabaaabbbbaaaa -> a

# < a,b | baabaaabbbbbaaa=a >
baabaaabbbbbaaa -> a

# < a,b | baabaaabbbbbbba=a >
baabaaabbbbbbba -> a
baabaaabbbbbba -> aabaaabbbbbbba
baabaaabbbbba -> aabaaabbbbbba
baabaaabbbba -> aabaaabbbbba
baabaaabbba -> aabaaabbbba
baabaaabba -> aabaaabbba
baabaaaba -> aabaaabba
baabaaaa -> aabaaaba

# < a,b | baabaabaaaaaaaa=a >
baabaabaaaaaaaa -> a

# < a,b | baabaabaaaaaaba=a >
baabaabaaaaaaba -> a
baabaabaaaaaaa -> aabaabaaaaaaba

# < a,b | baabaabaaaaabaa=a >
baabaabaaaaabaa -> a
baabaabaaaaaa -> abaabaaaaabaa

# < a,b | baabaabaaaaabba=a >
baabaabaaaaabba -> a
baabaabaaaaaba -> aabaabaaaaabba
baabaabaaaaaa -> aabaabaaaaaba

# < a,b | baabaabaaaabaaa=a >
baabaabaaaabaaa -> a

# < a,b | baabaabaaaabbba=a >
baabaabaaaabbba -> a
baabaabaaaabba -> aabaabaaaabbba
baabaabaaaaba -> aabaabaaaabba
baabaabaaaaa -> aabaabaaaaba

# < a,b | baabaabaaabaaaa=a >
baabaabaaabaaaa -> a

# < a,b | baabaabaaabaaba=a >
baabaabaaabaaba -> a
baabaabaaabaaa -> aabaabaaabaaba
baabaabaaaa -> aabaaabaaba

# < a,b | baabaabaaababaa=a >
baabaabaaababaa -> a
baabaabaaabaa -> abaabaaababaa
baabaabaaaa -> abaabaaabaa

# < a,b | baabaabaaabbaaa=a >
baabaabaaabbaaa -> a

# < a,b | baabaabaaabbbba=a >
baabaabaaabbbba -> a
baabaabaaabbba -> aabaabaaabbbba
baabaabaaabba -> aabaabaaabbba
baabaabaaaba -> aabaabaaabba
baabaabaaaa -> aabaabaaaba

# < a,b | baabaabaabaaaaa=a >
baabaabaabaaaaa -> a

# < a,b | baabaabaabaaaba=a >
baabaabaabaaaba -> a
baabaabaabaaaa -> aabaabaabaaaba

# < a,b | baabaabaabaabaa=a >
baabaabaabaabaa -> a
baaa -> abaa

# < a,b | baabaabaababaaa=a >
baabaabaababaaa -> a

# < a,b | baabaabaabbaaaa=a >
baabaabaabbaaaa -> a

# < a,b | baabaabaabbbaaa=a >
baabaabaabbbaaa -> a

# < a,b | baabaababaaaaaa=a >
baabaababaaaaaa -> a

# < a,b | baabaababaaaaba=a >
baabaababaaaaba -> a
baabaababaaaaa -> aabaababaaaaba

# < a,b | baabaababaaabaa=a >
baabaababaaabaa -> a
baabaababaaaa -> abaababaaabaa

# < a,b | baabaababaaabba=a >
baabaababaaabba -> a
baabaababaaaba -> aabaababaaabba
baabaababaaaa -> aabaababaaaba

# < a,b | baabaababaabaaa=a >
baabaababaabaaa -> a

# < a,b | baabaabababaaaa=a >
baabaabababaaaa -> a

# < a,b | baabaabababbaaa=a >
baabaabababbaaa -> a

# < a,b | baabaababbaaaaa=a >
baabaababbaaaaa -> a

# < a,b | baabaababbaaaba=a >
baabaababbaaaba -> a
baabaababbaaaa -> aabaababbaaaba

# < a,b | baabaababbabaaa=a >
baabaababbabaaa -> a

# < a,b | baabaababbbaaaa=a >
baabaababbbaaaa -> a

# < a,b | baabaababbbbaaa=a >
baabaababbbbaaa -> a

# < a,b | baabaabbaaaaaaa=a >
baabaabbaaaaaaa -> a

# < a,b | baabaabbaaaaaba=a >
baabaabbaaaaaba -> a
baabaabbaaaaaa -> aabaabbaaaaaba

# < a,b | baabaabbaaaabaa=a >
baabaabbaaaabaa -> a
baabaabbaaaaa -> abaabbaaaabaa

# < a,b | baabaabbaaaabba=a >
baabaabbaaaabba -> a
baabaabbaaaaba -> aabaabbaaaabba
baabaabbaaaaa -> aabaabbaaaaba

# < a,b | baabaabbaaabaaa=a >
baabaabbaaabaaa -> a

# < a,b | baabaabbaaabbba=a >
baabaabbaaabbba -> a
baabaabbaaabba -> aabaabbaaabbba
baabaabbaaaba -> aabaabbaaabba
baabaabbaaaa -> aabaabbaaaba

# < a,b | baabaabbaabaaaa=a >
baabaabbaabaaaa -> a

# < a,b | baabaabbaabaaba=a >
baabaabbaabaaba -> a
baabaabbaabaaa -> aabaabbaabaaba
baabaabbaaa -> aabbaabaaba

# < a,b | baabaabbaabbaaa=a >
baabaabbaabbaaa -> a

# < a,b | baabaabbabaaaaa=a >
baabaabbabaaaaa -> a

# < a,b | baabaabbabaaaba=a >
baabaabbabaaaba -> a
baabaabbabaaaa -> aabaabbabaaaba

# < a,b | baabaabbababaaa=a >
baabaabbababaaa -> a

# < a,b | baabaabbabbaaaa=a >
baabaabbabbaaaa -> a

# < a,b | baabaabbabbbaaa=a >
baabaabbabbbaaa -> a

# < a,b | baabaabbbaaaaaa=a >
baabaabbbaaaaaa -> a

# < a,b | baabaabbbaaaaba=a >
baabaabbbaaaaba -> a
baabaabbbaaaaa -> aabaabbbaaaaba

# < a,b | baabaabbbaaabaa=a >
baabaabbbaaabaa -> a
baabaabbbaaaa -> abaabbbaaabaa

# < a,b | baabaabbbaaabba=a >
baabaabbbaaabba -> a
baabaabbbaaaba -> aabaabbbaaabba
baabaabbbaaaa -> aabaabbbaaaba

# < a,b | baabaabbbaabaaa=a >
baabaabbbaabaaa -> a

# < a,b | baabaabbbabaaaa=a >
baabaabbbabaaaa -> a

# < a,b | baabaabbbabbaaa=a >
baabaabbbabbaaa -> a

# < a,b | baabaabbbbaaaaa=a >
baabaabbbbaaaaa -> a

# < a,b | baabaabbbbaaaba=a >
baabaabbbbaaaba -> a
baabaabbbbaaaa -> aabaabbbbaaaba

# < a,b | baabaabbbbabaaa=a >
baabaabbbbabaaa -> a

# < a,b | baabaabbbbbaaaa=a >
baabaabbbbbaaaa -> a

# < a,b | baabaabbbbbbaaa=a >
baabaabbbbbbaaa -> a

# < a,b | baababaaaaaaaaa=a >
baababaaaaaaaaa -> a

# < a,b | baababaaaaaaaba=a >
baababaaaaaaaba -> a
baababaaaaaaaa -> aababaaaaaaaba

# < a,b | baababaaaaaabaa=a >
baababaaaaaabaa -> a
baababaaaaaaa -> ababaaaaaabaa

# < a,b | baababaaaaaabba=a >
baababaaaaaabba -> a
baababaaaaaaba -> aababaaaaaabba
baababaaaaaaa -> aababaaaaaaba

# < a,b | baababaaaaabaaa=a >
baababaaaaabaaa -> a

# < a,b | baababaaaaabbba=a >
baababaaaaabbba -> a
baababaaaaabba -> aababaaaaabbba
baababaaaaaba -> aababaaaaabba
baababaaaaaa -> aababaaaaaba

# < a,b | baababaaaabaaaa=a >
baababaaaabaaaa -> a

# < a,b | baababaaaabaaba=a >
baababaaaabaaba -> a
baababaaaabaaa -> aababaaaabaaba
baababaaaaa -> abaaaabaaba

# < a,b | baababaaaababaa=a >
baababaaaababaa -> a
baababaaaabaa -> ababaaaababaa
baababaaaaa -> ababaaaabaa

# < a,b | baababaaaabbaaa=a >
baababaaaabbaaa -> a

# < a,b | baababaaaabbbba=a >
baababaaaabbbba -> a
baababaaaabbba -> aababaaaabbbba
baababaaaabba -> aababaaaabbba
baababaaaaba -> aababaaaabba
baababaaaaa -> aababaaaaba

# < a,b | baababaaabaaaaa=a >
baababaaabaaaaa -> a

# < a,b | baababaaabaaaba=a >
baababaaabaaaba -> a
baababaaabaaaa -> aababaaabaaaba

# < a,b | baababaaabaabaa=a >
baababaaabaabaa -> a
baababaaabaaa -> ababaaabaabaa

# < a,b | baababaaababaaa=a >
baababaaababaaa -> a

# < a,b | baababaaabbaaaa=a >
baababaaabbaaaa -> a

# < a,b | baababaaabbaaba=a >
baababaaabbaaba -> a
baababaaabbaaa -> aababaaabbaaba
baababaaaba -> abaaabbaaba
baababaaaa -> abaaabbaaa

# < a,b | baababaaabbbaaa=a >
baababaaabbbaaa -> a

# < a,b | baababaaabbbbba=a >
baababaaabbbbba -> a
baababaaabbbba -> aababaaabbbbba
baababaaabbba -> aababaaabbbba
baababaaabba -> aababaaabbba
baababaaaba -> aababaaabba
baababaaaa -> aababaaaba

# < a,b | baababaabaaaaaa=a >
baababaabaaaaaa -> a

# < a,b | baababaabaaaaba=a >
baababaabaaaaba -> a
baababaabaaaaa -> aababaabaaaaba

# < a,b | baababaabaaabaa=a >
baababaabaaabaa -> a
baababaabaaaa -> ababaabaaabaa

# < a,b | baababaabaaabba=a >
baababaabaaabba -> a
baababaabaaaba -> aababaabaaabba
baababaabaaaa -> aababaabaaaba

# < a,b | baababaabaabaaa=a >
baababaabaabaaa -> a

# < a,b | baababaababaaaa=a >
baababaababaaaa -> a

# < a,b | baababaababbaaa=a >
baababaababbaaa -> a

# < a,b | baababaabbaaaaa=a >
baababaabbaaaaa -> a

# < a,b | baababaabbaaaba=a >
baababaabbaaaba -> a
baababaabbaaaa -> aababaabbaaaba

# < a,b | baababaabbaabaa=a >
baababaabbaabaa -> a
baababaabbaaa -> ababaabbaabaa

# < a,b | baababaabbabaaa=a >
baababaabbabaaa -> a

# < a,b | baababaabbbaaaa=a >
baababaabbbaaaa -> a

# < a,b | baababaabbbbaaa=a >
baababaabbbbaaa -> a

# < a,b | baabababaaaaaaa=a >
baabababaaaaaaa -> a

# < a,b | baabababaaaaaba=a >
baabababaaaaaba -> a
baabababaaaaaa -> aabababaaaaaba

# < a,b | baabababaaaabaa=a >
baabababaaaabaa -> a
baabababaaaaa -> abababaaaabaa

# < a,b | baabababaaaabba=a >
baabababaaaabba -> a
baabababaaaaba -> aabababaaaabba
baabababaaaaa -> aabababaaaaba

# < a,b | baabababaaabaaa=a >
baabababaaabaaa -> a

# < a,b | baabababaaabbba=a >
baabababaaabbba -> a
baabababaaabba -> aabababaaabbba
baabababaaaba -> aabababaaabba
baabababaaaa -> aabababaaaba

# < a,b | baabababaabaaaa=a >
baabababaabaaaa -> a

# < a,b | baabababaabaaba=a >
baabababaabaaba -> a
baabababaabaaa -> aabababaabaaba
baabababaaa -> ababaabaaba

# < a,b | baabababaababaa=a >
baabababaababaa -> a
baabababaabaa -> abababaababaa
baabababaaa -> abababaabaa

# < a,b | baabababaabbaaa=a >
baabababaabbaaa -> a

# < a,b | baababababaaaaa=a >
baababababaaaaa -> a

# < a,b | baababababaaaba=a >
baababababaaaba -> a
baababababaaaa -> aababababaaaba

# < a,b | baababababaabaa=a >
baababababaabaa -> a
baababababaaa -> ababababaabaa

# < a,b | baabababababaaa=a >
baabababababaaa -> a

# < a,b | baababababbaaaa=a >
baababababbaaaa -> a

# < a,b | baababababbbaaa=a >
baababababbbaaa -> a

# < a,b | baabababbaaaaaa=a >
baabababbaaaaaa -> a

# < a,b | baabababbaaaaba=a >
baabababbaaaaba -> a
baabababbaaaaa -> aabababbaaaaba

# < a,b | baabababbaaabaa=a >
baabababbaaabaa -> a
baabababbaaaa -> abababbaaabaa

# < a,b | baabababbaaabba=a >
baabababbaaabba -> a
baabababbaaaba -> aabababbaaabba
baabababbaaaa -> aabababbaaaba

# < a,b | baabababbaabaaa=a >
baabababbaabaaa -> a

# < a,b | baabababbabaaaa=a >
baabababbabaaaa -> a

# < a,b | baabababbabbaaa=a >
baabababbabbaaa -> a

# < a,b | baabababbbaaaaa=a >
baabababbbaaaaa -> a

# < a,b | baabababbbaaaba=a >
baabababbbaaaba -> a
baabababbbaaaa -> aabababbbaaaba

# < a,b | baabababbbaabaa=a >
baabababbbaabaa -> a
baabababbbaaa -> abababbbaabaa

# < a,b | baabababbbabaaa=a >
baabababbbabaaa -> a

# < a,b | baabababbbbaaaa=a >
baabababbbbaaaa -> a

# < a,b | baabababbbbbaaa=a >
baabababbbbbaaa -> a

# < a,b | baababbaaaaaaaa=a >
baababbaaaaaaaa -> a

# < a,b | baababbaaaaaaba=a >
baababbaaaaaaba -> a
baababbaaaaaaa -> aababbaaaaaaba

# < a,b | baababbaaaaabaa=a >
baababbaaaaabaa -> a
baababbaaaaaa -> ababbaaaaabaa

# < a,b | baababbaaaaabba=a >
baababbaaaaabba -> a
baababbaaaaaba -> aababbaaaaabba
baababbaaaaaa -> aababbaaaaaba

# < a,b | baababbaaaabaaa=a >
baababbaaaabaaa -> a

# < a,b | baababbaaaabbba=a >
baababbaaaabbba -> a
baababbaaaabba -> aababbaaaabbba
baababbaaaaba -> aababbaaaabba
baababbaaaaa -> aababbaaaaba

# < a,b | baababbaaabaaaa=a >
baababbaaabaaaa -> a

# < a,b | baababbaaabaaba=a >
baababbaaabaaba -> a
baababbaaabaaa -> aababbaaabaaba
baababbaaaa -> abbaaabaaba

# < a,b | baababbaaababaa=a >
baababbaaababaa -> a
baababbaaabaa -> ababbaaababaa
baababbaaaa -> ababbaaabaa

# < a,b | baababbaaabbaaa=a >
baababbaaabbaaa -> a

# < a,b | baababbaaabbbba=a >
baababbaaabbbba -> a
baababbaaabbba -> aababbaaabbbba
baababbaaabba -> aababbaaabbba
baababbaaaba -> aababbaaabba
baababbaaaa -> aababbaaaba

# < a,b | baababbaabaaaaa=a >
baababbaabaaaaa -> a

# < a,b | baababbaabaaaba=a >
baababbaabaaaba -> a
baababbaabaaaa -> aababbaabaaaba

# < a,b | baababbaabaabaa=a >
baababbaabaabaa -> a
baababbaabaaa -> ababbaabaabaa

# < a,b | baababbaababaaa=a >
baababbaababaaa -> a

# < a,b | baababbaabbaaaa=a >
baababbaabbaaaa -> a

# < a,b | baababbaabbbaaa=a >
baababbaabbbaaa -> a

# < a,b | baababbabaaaaaa=a >
baababbabaaaaaa -> a

# < a,b | baababbabaaaaba=a >
baababbabaaaaba -> a
baababbabaaaaa -> aababbabaaaaba

# < a,b | baababbabaaabaa=a >
baababbabaaabaa -> a
baababbabaaaa -> ababbabaaabaa

# < a,b | baababbabaaabba=a >
baababbabaaabba -> a
baababbabaaaba -> aababbabaaabba
baababbabaaaa -> aababbabaaaba

# < a,b | baababbabaabaaa=a >
baababbabaabaaa -> a

# < a,b | baababbababaaaa=a >
baababbababaaaa -> a

# < a,b | baababbababbaaa=a >
baababbababbaaa -> a

# < a,b | baababbabbaaaaa=a >
baababbabbaaaaa -> a

# < a,b | baababbabbaaaba=a >
baababbabbaaaba -> a
baababbabbaaaa -> aababbabbaaaba

# < a,b | baababbabbaabaa=a >
baababbabbaabaa -> a
baababbabbaaa -> ababbabbaabaa

# < a,b | baababbabbabaaa=a >
baababbabbabaaa -> a

# < a,b | baababbabbbaaaa=a >
baababbabbbaaaa -> a

# < a,b | baababbabbbbaaa=a >
baababbabbbbaaa -> a

# < a,b | baababbbaaaaaaa=a >
baababbbaaaaaaa -> a

# < a,b | baababbbaaaaaba=a >
baababbbaaaaaba -> a
baababbbaaaaaa -> aababbbaaaaaba

# < a,b | baababbbaaaabaa=a >
baababbbaaaabaa -> a
baababbbaaaaa -> ababbbaaaabaa

# < a,b | baababbbaaaabba=a >
baababbbaaaabba -> a
baababbbaaaaba -> aababbbaaaabba
baababbbaaaaa -> aababbbaaaaba

# < a,b | baababbbaaabaaa=a >
baababbbaaabaaa -> a

# < a,b | baababbbaaabbba=a >
baababbbaaabbba -> a
baababbbaaabba -> aababbbaaabbba
baababbbaaaba -> aababbbaaabba
baababbbaaaa -> aababbbaaaba

# < a,b | baababbbaabaaaa=a >
baababbbaabaaaa -> a

# < a,b | baababbbaabaaba=a >
baababbbaabaaba -> a
baababbbaabaaa -> aababbbaabaaba
baababbbaaa -> abbbaabaaba

# < a,b | baababbbaababaa=a >
baababbbaababaa -> a
baababbbaabaa -> ababbbaababaa
baababbbaaa -> ababbbaabaa

# < a,b | baababbbaabbaaa=a >
baababbbaabbaaa -> a

# < a,b | baababbbabaaaaa=a >
baababbbabaaaaa -> a

# < a,b | baababbbabaaaba=a >
baababbbabaaaba -> a
baababbbabaaaa -> aababbbabaaaba

# < a,b | baababbbabaabaa=a >
baababbbabaabaa -> a
baababbbabaaa -> ababbbabaabaa

# < a,b | baababbbababaaa=a >
baababbbababaaa -> a

# < a,b | baababbbabbaaaa=a >
baababbbabbaaaa -> a

# < a,b | baababbbabbbaaa=a >
baababbbabbbaaa -> a

# < a,b | baababbbbaaaaaa=a >
baababbbbaaaaaa -> a

# < a,b | baababbbbaaaaba=a >
baababbbbaaaaba -> a
baababbbbaaaaa -> aababbbbaaaaba

# < a,b | baababbbbaaabaa=a >
baababbbbaaabaa -> a
baababbbbaaaa -> ababbbbaaabaa

# < a,b | baababbbbaaabba=a >
baababbbbaaabba -> a
baababbbbaaaba -> aababbbbaaabba
baababbbbaaaa -> aababbbbaaaba

# < a,b | baababbbbaabaaa=a >
baababbbbaabaaa -> a

# < a,b | baababbbbabaaaa=a >
baababbbbabaaaa -> a

# < a,b | baababbbbabbaaa=a >
baababbbbabbaaa -> a

# < a,b | baababbbbbaaaaa=a >
baababbbbbaaaaa -> a

# < a,b | baababbbbbaaaba=a >
baababbbbbaaaba -> a
baababbbbbaaaa -> aababbbbbaaaba

# < a,b | baababbbbbaabaa=a >
baababbbbbaabaa -> a
baababbbbbaaa -> ababbbbbaabaa

# < a,b | baababbbbbabaaa=a >
baababbbbbabaaa -> a

# < a,b | baababbbbbbaaaa=a >
baababbbbbbaaaa -> a

# < a,b | baababbbbbbbaaa=a >
baababbbbbbbaaa -> a

# < a,b | baabbaaaaaaaaaa=a >
baabbaaaaaaaaaa -> a

# < a,b | baabbaaaaaaaaba=a >
baabbaaaaaaaaba -> a
baabbaaaaaaaaa -> aabbaaaaaaaaba

# < a,b | baabbaaaaaaabaa=a >
baabbaaaaaaabaa -> a
baabbaaaaaaaa -> abbaaaaaaabaa

# < a,b | baabbaaaaaaabba=a >
baabbaaaaaaabba -> a
baabbaaaaaaaba -> aabbaaaaaaabba
baabbaaaaaaaa -> aabbaaaaaaaba

# < a,b | baabbaaaaaabaaa=a >
baabbaaaaaabaaa -> a

# < a,b | baabbaaaaaabbba=a >
baabbaaaaaabbba -> a
baabbaaaaaabba -> aabbaaaaaabbba
baabbaaaaaaba -> aabbaaaaaabba
baabbaaaaaaa -> aabbaaaaaaba

# < a,b | baabbaaaaabaaaa=a >
baabbaaaaabaaaa -> a

# < a,b | baabbaaaaabaaba=a >
baabbaaaaabaaba -> a
baabbaaaaabaaa -> aabbaaaaabaaba

# < a,b | baabbaaaaababaa=a >
baabbaaaaababaa -> a
baabbaaaaabaa -> abbaaaaababaa
baabbaaaaaa -> abbaaaaabaa

# < a,b | baabbaaaaabbaaa=a >
baabbaaaaabbaaa -> a

# < a,b | baabbaaaaabbbba=a >
baabbaaaaabbbba -> a
baabbaaaaabbba -> aabbaaaaabbbba
baabbaaaaabba -> aabbaaaaabbba
baabbaaaaaba -> aabbaaaaabba
baabbaaaaaa -> aabbaaaaaba

# < a,b | baabbaaaabaaaaa=a >
baabbaaaabaaaaa -> a

# < a,b | baabbaaaabaaaba=a >
baabbaaaabaaaba -> a
baabbaaaabaaaa -> aabbaaaabaaaba

# < a,b | baabbaaaabaabaa=a >
baabbaaaabaabaa -> a
baabbaaaabaaa -> abbaaaabaabaa

# < a,b | baabbaaaabaabba=a >
baabbaaaabaabba -> a
baabbaaaabaaba -> aabbaaaabaabba
baabbaaaaa -> aaaabaabba
baabbaaaabaaa -> aabbaaaabaaba

# < a,b | baabbaaaababaaa=a >
baabbaaaababaaa -> a

# < a,b | baabbaaaabbaaaa=a >
baabbaaaabbaaaa -> a

# < a,b | baabbaaaabbaaba=a >
baabbaaaabbaaba -> a
baabbaaaabbaaa -> aabbaaaabbaaba

# < a,b | baabbaaaabbbaaa=a >
baabbaaaabbbaaa -> a

# < a,b | baabbaaaabbbbba=a >
baabbaaaabbbbba -> a
baabbaaaabbbba -> aabbaaaabbbbba
baabbaaaabbba -> aabbaaaabbbba
baabbaaaabba -> aabbaaaabbba
baabbaaaaba -> aabbaaaabba
baabbaaaaa -> aabbaaaaba

# < a,b | baabbaaabaaaaaa=a >
baabbaaabaaaaaa -> a

# < a,b | baabbaaabaaaaba=a >
baabbaaabaaaaba -> a
baabbaaabaaaaa -> aabbaaabaaaaba

# < a,b | baabbaaabaaabaa=a >
baabbaaabaaabaa -> a
baabbaaabaaaa -> abbaaabaaabaa

# < a,b | baabbaaabaaabba=a >
baabbaaabaaabba -> a
baabbaaabaaaba -> aabbaaabaaabba
baabbaaabaaaa -> aabbaaabaaaba

# < a,b | baabbaaabaabaaa=a >
baabbaaabaabaaa -> a

# < a,b | baabbaaababaaaa=a >
baabbaaababaaaa -> a

# < a,b | baabbaaababaaba=a >
baabbaaababaaba -> a
baabbaaababaaa -> aabbaaababaaba

# < a,b | baabbaaabababaa=a >
baabbaaabababaa -> a
baabbaaababaa -> abbaaabababaa
baabbaaabaa -> abbaaababaa
baabbaaaa -> abbaaabaa

# < a,b | baabbaaababbaaa=a >
baabbaaababbaaa -> a

# < a,b | baabbaaabbaaaaa=a >
baabbaaabbaaaaa -> a

# < a,b | baabbaaabbaaaba=a >
baabbaaabbaaaba -> a
baabbaaabbaaaa -> aabbaaabbaaaba

# < a,b | baabbaaabbaabaa=a >
baabbaaabbaabaa -> a
baabbaaabbaaa -> abbaaabbaabaa

# < a,b | baabbaaabbaabba=a >
baabbaaabbaabba -> a
baabbaaabbaaba -> aabbaaabbaabba
baabbaaaba -> aaabbaabba
baabbaaabbaaa -> aabbaaabbaaba
baabbaaaa -> aaabbaaba

# < a,b | baabbaaabbabaaa=a >
baabbaaabbabaaa -> a

# < a,b | baabbaaabbbaaaa=a >
baabbaaabbbaaaa -> a

# < a,b | baabbaaabbbaaba=a >
baabbaaabbbaaba -> a
baabbaaabbbaaa -> aabbaaabbbaaba

# < a,b | baabbaaabbbbaaa=a >
baabbaaabbbbaaa -> a

# < a,b | baabbaaabbbbbba=a >
baabbaaabbbbbba -> a
baabbaaabbbbba -> aabbaaabbbbbba
baabbaaabbbba -> aabbaaabbbbba
baabbaaabbba -> aabbaaabbbba
baabbaaabba -> aabbaaabbba
baabbaaaba -> aabbaaabba
baabbaaaa -> aabbaaaba

# < a,b | baabbaabaaaaaaa=a >
baabbaabaaaaaaa -> a

# < a,b | baabbaabaaaaaba=a >
baabbaabaaaaaba -> a
baabbaabaaaaaa -> aabbaabaaaaaba

# < a,b | baabbaabaaaabaa=a >
baabbaabaaaabaa -> a
baabbaabaaaaa -> abbaabaaaabaa

# < a,b | baabbaabaaaabba=a >
baabbaabaaaabba -> a
baabbaabaaaaba -> aabbaabaaaabba
baabbaabaaaaa -> aabbaabaaaaba

# < a,b | baabbaabaaabaaa=a >
baabbaabaaabaaa -> a

# < a,b | baabbaabaaabbba=a >
baabbaabaaabbba -> a
baabbaabaaabba -> aabbaabaaabbba
baabbaabaaaba -> aabbaabaaabba
baabbaabaaaa -> aabbaabaaaba

# < a,b | baabbaabaabaaaa=a >
baabbaabaabaaaa -> a

# < a,b | baabbaabaabaaba=a >
baabbaabaabaaba -> a
baabbaabaabaaa -> aabbaabaabaaba

# < a,b | baabbaabaababaa=a >
baabbaabaababaa -> a
baabbaabaabaa -> abbaabaababaa
baabbaabaaa -> abbaabaabaa

# < a,b | baabbaabaabbaaa=a >
baabbaabaabbaaa -> a

# < a,b | baabbaababaaaaa=a >
baabbaababaaaaa -> a

# < a,b | baabbaababaaaba=a >
baabbaababaaaba -> a
baabbaababaaaa -> aabbaababaaaba

# < a,b | baabbaababaabaa=a >
baabbaababaabaa -> a
baabbaababaaa -> abbaababaabaa

# < a,b | baabbaabababaaa=a >
baabbaabababaaa -> a

# < a,b | baabbaababbaaaa=a >
baabbaababbaaaa -> a

# < a,b | baabbaababbaaba=a >
baabbaababbaaba -> a
baabbaababbaaa -> aabbaababbaaba

# < a,b | baabbaababbbaaa=a >
baabbaababbbaaa -> a

# < a,b | baabbaabbaaaaaa=a >
baabbaabbaaaaaa -> a

# < a,b | baabbaabbaaaaba=a >
baabbaabbaaaaba -> a
baabbaabbaaaaa -> aabbaabbaaaaba

# < a,b | baabbaabbaaabaa=a >
baabbaabbaaabaa -> a
baabbaabbaaaa -> abbaabbaaabaa

# < a,b | baabbaabbaaabba=a >
baabbaabbaaabba -> a
baabbaabbaaaba -> aabbaabbaaabba
baabbaabbaaaa -> aabbaabbaaaba

# < a,b | baabbaabbaabaaa=a >
baabbaabbaabaaa -> a

# < a,b | baabbaabbabaaaa=a >
baabbaabbabaaaa -> a

# < a,b | baabbaabbabaaba=a >
baabbaabbabaaba -> a
baabbaabbabaaa -> aabbaabbabaaba

# < a,b | baabbaabbabbaaa=a >
baabbaabbabbaaa -> a

# < a,b | baabbaabbbaaaaa=a >
baabbaabbbaaaaa -> a

# < a,b | baabbaabbbaaaba=a >
baabbaabbbaaaba -> a
baabbaabbbaaaa -> aabbaabbbaaaba

# < a,b | baabbaabbbaabaa=a >
baabbaabbbaabaa -> a
baabbaabbbaaa -> abbaabbbaabaa

# < a,b | baabbaabbbaabba=a >
baabbaabbbaabba -> a
baabbaabba -> aabbbaabba
baaba -> aabba
baaa -> aaba

# < a,b | baabbaabbbabaaa=a >
baabbaabbbabaaa -> a

# < a,b | baabbaabbbbaaaa=a >
baabbaabbbbaaaa -> a

# < a,b | baabbaabbbbaaba=a >
baabbaabbbbaaba -> a
baabbaabbbbaaa -> aabbaabbbbaaba

# < a,b | baabbaabbbbbaaa=a >
baabbaabbbbbaaa -> a

# < a,b | baabbabaaaaaaaa=a >
baabbabaaaaaaaa -> a

# < a,b | baabbabaaaaaaba=a >
baabbabaaaaaaba -> a
baabbabaaaaaaa -> aabbabaaaaaaba

# < a,b | baabbabaaaaabaa=a >
baabbabaaaaabaa -> a
baabbabaaaaaa -> abbabaaaaabaa

# < a,b | baabbabaaaaabba=a >
baabbabaaaaabba -> a
baabbabaaaaaba -> aabbabaaaaabba
baabbabaaaaaa -> aabbabaaaaaba

# < a,b | baabbabaaaabaaa=a >
baabbabaaaabaaa -> a

# < a,b | baabbabaaaabbba=a >
baabbabaaaabbba -> a
baabbabaaaabba -> aabbabaaaabbba
baabbabaaaaba -> aabbabaaaabba
baabbabaaaaa -> aabbabaaaaba

# < a,b | baabbabaaabaaaa=a >
baabbabaaabaaaa -> a

# < a,b | baabbabaaabaaba=a >
baabbabaaabaaba -> a
baabbabaaabaaa -> aabbabaaabaaba

# < a,b | baabbabaaababaa=a >
baabbabaaababaa -> a
baabbabaaabaa -> abbabaaababaa
baabbabaaaa -> abbabaaabaa

# < a,b | baabbabaaabbaaa=a >
baabbabaaabbaaa -> a

# < a,b | baabbabaaabbbba=a >
baabbabaaabbbba -> a
baabbabaaabbba -> aabbabaaabbbba
baabbabaaabba -> aabbabaaabbba
baabbabaaaba -> aabbabaaabba
baabbabaaaa -> aabbabaaaba

# < a,b | baabbabaabaaaaa=a >
baabbabaabaaaaa -> a

# < a,b | baabbabaabaaaba=a >
baabbabaabaaaba -> a
baabbabaabaaaa -> aabbabaabaaaba

# < a,b | baabbabaabaabaa=a >
baabbabaabaabaa -> a
baabbabaabaaa -> abbabaabaabaa

# < a,b | baabbabaabaabba=a >
baabbabaabaabba -> a
baabbabaabaaba -> aabbabaabaabba
baabbabaaa -> abaabaabba
baabbabaabaaa -> aabbabaabaaba

# < a,b | baabbabaababaaa=a >
baabbabaababaaa -> a

# < a,b | baabbabaabbaaaa=a >
baabbabaabbaaaa -> a

# < a,b | baabbabaabbaaba=a >
baabbabaabbaaba -> a
baabbabaabbaaa -> aabbabaabbaaba

# < a,b | baabbabaabbbaaa=a >
baabbabaabbbaaa -> a

# < a,b | baabbababaaaaaa=a >
baabbababaaaaaa -> a

# < a,b | baabbababaaaaba=a >
baabbababaaaaba -> a
baabbababaaaaa -> aabbababaaaaba

# < a,b | baabbababaaabaa=a >
baabbababaaabaa -> a
baabbababaaaa -> abbababaaabaa

# < a,b | baabbababaaabba=a >
baabbababaaabba -> a
baabbababaaaba -> aabbababaaabba
baabbababaaaa -> aabbababaaaba

# < a,b | baabbababaabaaa=a >
baabbababaabaaa -> a

# < a,b | baabbabababaaaa=a >
baabbabababaaaa -> a

# < a,b | baabbabababaaba=a >
baabbabababaaba -> a
baabbabababaaa -> aabbabababaaba

# < a,b | baabbabababbaaa=a >
baabbabababbaaa -> a

# < a,b | baabbababbaaaaa=a >
baabbababbaaaaa -> a

# < a,b | baabbababbaaaba=a >
baabbababbaaaba -> a
baabbababbaaaa -> aabbababbaaaba

# < a,b | baabbababbaabaa=a >
baabbababbaabaa -> a
baabbababbaaa -> abbababbaabaa

# < a,b | baabbababbabaaa=a >
baabbababbabaaa -> a

# < a,b | baabbababbbaaaa=a >
baabbababbbaaaa -> a

# < a,b | baabbababbbaaba=a >
baabbababbbaaba -> a
baabbababbbaaa -> aabbababbbaaba

# < a,b | baabbababbbbaaa=a >
baabbababbbbaaa -> a

# < a,b | baabbabbaaaaaaa=a >
baabbabbaaaaaaa -> a

# < a,b | baabbabbaaaaaba=a >
baabbabbaaaaaba -> a
baabbabbaaaaaa -> aabbabbaaaaaba

# < a,b | baabbabbaaaabaa=a >
baabbabbaaaabaa -> a
baabbabbaaaaa -> abbabbaaaabaa

# < a,b | baabbabbaaaabba=a >
baabbabbaaaabba -> a
baabbabbaaaaba -> aabbabbaaaabba
baabbabbaaaaa -> aabbabbaaaaba

# < a,b | baabbabbaaabaaa=a >
baabbabbaaabaaa -> a

# < a,b | baabbabbaaabbba=a >
baabbabbaaabbba -> a
baabbabbaaabba -> aabbabbaaabbba
baabbabbaaaba -> aabbabbaaabba
baabbabbaaaa -> aabbabbaaaba

# < a,b | baabbabbaabaaaa=a >
baabbabbaabaaaa -> a

# < a,b | baabbabbaabaaba=a >
baabbabbaabaaba -> a
baabbabbaabaaa -> aabbabbaabaaba

# < a,b | baabbabbaababaa=a >
baabbabbaababaa -> a
baabbabbaabaa -> abbabbaababaa
baabbabbaaa -> abbabbaabaa

# < a,b | baabbabbaabbaaa=a >
baabbabbaabbaaa -> a

# < a,b | baabbabbabaaaaa=a >
baabbabbabaaaaa -> a

# < a,b | baabbabbabaaaba=a >
baabbabbabaaaba -> a
baabbabbabaaaa -> aabbabbabaaaba

# < a,b | baabbabbabaabaa=a >
baabbabbabaabaa -> a
baabbabbabaaa -> abbabbabaabaa

# < a,b | baabbabbababaaa=a >
baabbabbababaaa -> a

# < a,b | baabbabbabbaaaa=a >
baabbabbabbaaaa -> a

# < a,b | baabbabbabbaaba=a >
baabbabbabbaaba -> a
baabbabbabbaaa -> aabbabbabbaaba

# < a,b | baabbabbabbbaaa=a >
baabbabbabbbaaa -> a

# < a,b | baabbabbbaaaaaa=a >
baabbabbbaaaaaa -> a

# < a,b | baabbabbbaaaaba=a >
baabbabbbaaaaba -> a
baabbabbbaaaaa -> aabbabbbaaaaba

# < a,b | baabbabbbaaabaa=a >
baabbabbbaaabaa -> a
baabbabbbaaaa -> abbabbbaaabaa

# < a,b | baabbabbbaaabba=a >
baabbabbbaaabba -> a
baabbabbbaaaba -> aabbabbbaaabba
baabbabbbaaaa -> aabbabbbaaaba

# < a,b | baabbabbbaabaaa=a >
baabbabbbaabaaa -> a

# < a,b | baabbabbbabaaaa=a >
baabbabbbabaaaa -> a

# < a,b | baabbabbbabaaba=a >
baabbabbbabaaba -> a
baabbabbbabaaa -> aabbabbbabaaba

# < a,b | baabbabbbabbaaa=a >
baabbabbbabbaaa -> a

# < a,b | baabbabbbbaaaaa=a >
baabbabbbbaaaaa -> a

# < a,b | baabbabbbbaaaba=a >
baabbabbbbaaaba -> a
baabbabbbbaaaa -> aabbabbbbaaaba

# < a,b | baabbabbbbaabaa=a >
baabbabbbbaabaa -> a
baabbabbbbaaa -> abbabbbbaabaa

# < a,b | baabbabbbbabaaa=a >
baabbabbbbabaaa -> a

# < a,b | baabbabbbbbaaaa=a >
baabbabbbbbaaaa -> a

# < a,b | baabbabbbbbaaba=a >
baabbabbbbbaaba -> a
baabbabbbbbaaa -> aabbabbbbbaaba

# < a,b | baabbabbbbbbaaa=a >
baabbabbbbbbaaa -> a

# < a,b | baabbbaaaaaaaaa=a >
baabbbaaaaaaaaa -> a

# < a,b | baabbbaaaaaaaba=a >
baabbbaaaaaaaba -> a
baabbbaaaaaaaa -> aabbbaaaaaaaba

# < a,b | baabbbaaaaaabaa=a >
baabbbaaaaaabaa -> a
baabbbaaaaaaa -> abbbaaaaaabaa

# < a,b | baabbbaaaaaabba=a >
baabbbaaaaaabba -> a
baabbbaaaaaaba -> aabbbaaaaaabba
baabbbaaaaaaa -> aabbbaaaaaaba

# < a,b | baabbbaaaaabaaa=a >
baabbbaaaaabaaa -> a

# < a,b | baabbbaaaaabbba=a >
baabbbaaaaabbba -> a
baabbbaaaaabba -> aabbbaaaaabbba
baabbbaaaaaba -> aabbbaaaaabba
baabbbaaaaaa -> aabbbaaaaaba

# < a,b | baabbbaaaabaaaa=a >
baabbbaaaabaaaa -> a

# < a,b | baabbbaaaabaaba=a >
baabbbaaaabaaba -> a
baabbbaaaabaaa -> aabbbaaaabaaba

# < a,b | baabbbaaaababaa=a >
baabbbaaaababaa -> a
baabbbaaaabaa -> abbbaaaababaa
baabbbaaaaa -> abbbaaaabaa

# < a,b | baabbbaaaabbaaa=a >
baabbbaaaabbaaa -> a

# < a,b | baabbbaaaabbbba=a >
baabbbaaaabbbba -> a
baabbbaaaabbba -> aabbbaaaabbbba
baabbbaaaabba -> aabbbaaaabbba
baabbbaaaaba -> aabbbaaaabba
baabbbaaaaa -> aabbbaaaaba

# < a,b | baabbbaaabaaaaa=a >
baabbbaaabaaaaa -> a

# < a,b | baabbbaaabaaaba=a >
baabbbaaabaaaba -> a
baabbbaaabaaaa -> aabbbaaabaaaba

# < a,b | baabbbaaabaabaa=a >
baabbbaaabaabaa -> a
baabbbaaabaaa -> abbbaaabaabaa

# < a,b | baabbbaaabaabba=a >
baabbbaaabaabba -> a
baabbbaaabaaba -> aabbbaaabaabba
baabbbaaabaaa -> aabbbaaabaaba

# < a,b | baabbbaaababaaa=a >
baabbbaaababaaa -> a

# < a,b | baabbbaaabbaaaa=a >
baabbbaaabbaaaa -> a

# < a,b | baabbbaaabbaaba=a >
baabbbaaabbaaba -> a
baabbbaaabbaaa -> aabbbaaabbaaba

# < a,b | baabbbaaabbbaaa=a >
baabbbaaabbbaaa -> a

# < a,b | baabbbaaabbbbba=a >
baabbbaaabbbbba -> a
baabbbaaabbbba -> aabbbaaabbbbba
baabbbaaabbba -> aabbbaaabbbba
baabbbaaabba -> aabbbaaabbba
baabbbaaaba -> aabbbaaabba
baabbbaaaa -> aabbbaaaba

# < a,b | baabbbaabaaaaaa=a >
baabbbaabaaaaaa -> a

# < a,b | baabbbaabaaaaba=a >
baabbbaabaaaaba -> a
baabbbaabaaaaa -> aabbbaabaaaaba

# < a,b | baabbbaabaaabaa=a >
baabbbaabaaabaa -> a
baabbbaabaaaa -> abbbaabaaabaa

# < a,b | baabbbaabaaabba=a >
baabbbaabaaabba -> a
baabbbaabaaaba -> aabbbaabaaabba
baabbbaabaaaa -> aabbbaabaaaba

# < a,b | baabbbaabaabaaa=a >
baabbbaabaabaaa -> a

# < a,b | baabbbaabaabbba=a >
baabbbaabaabbba -> a
baabbbaabaabba -> aabbbaabaabbba
baabbbaaa -> aabaabbba
baabbbaabaaba -> aabbbaabaabba
baabbbaabaaa -> aabbbaabaaba

# < a,b | baabbbaababaaaa=a >
baabbbaababaaaa -> a

# < a,b | baabbbaababaaba=a >
baabbbaababaaba -> a
baabbbaababaaa -> aabbbaababaaba

# < a,b | baabbbaabababaa=a >
baabbbaabababaa -> a
baabbbaababaa -> abbbaabababaa
baabbbaabaa -> abbbaababaa
baabbbaaa -> abbbaabaa

# < a,b | baabbbaababbaaa=a >
baabbbaababbaaa -> a

# < a,b | baabbbaabbaaaaa=a >
baabbbaabbaaaaa -> a

# < a,b | baabbbaabbaaaba=a >
baabbbaabbaaaba -> a
baabbbaabbaaaa -> aabbbaabbaaaba

# < a,b | baabbbaabbaabaa=a >
baabbbaabbaabaa -> a
baabbbaabbaaa -> abbbaabbaabaa

# < a,b | baabbbaabbaabba=a >
baabbbaabbaabba -> a
baabbbaabbaaba -> aabbbaabbaabba
baabbbaabbaaa -> aabbbaabbaaba

# < a,b | baabbbaabbabaaa=a >
baabbbaabbabaaa -> a

# < a,b | baabbbaabbbaaaa=a >
baabbbaabbbaaaa -> a

# < a,b | baabbbaabbbaaba=a >
baabbbaabbbaaba -> a
baabbbaabbbaaa -> aabbbaabbbaaba

# < a,b | baabbbaabbbbaaa=a >
baabbbaabbbbaaa -> a

# < a,b | baabbbabaaaaaaa=a >
baabbbabaaaaaaa -> a

# < a,b | baabbbabaaaaaba=a >
baabbbabaaaaaba -> a
baabbbabaaaaaa -> aabbbabaaaaaba

# < a,b | baabbbabaaaabaa=a >
baabbbabaaaabaa -> a
baabbbabaaaaa -> abbbabaaaabaa

# < a,b | baabbbabaaaabba=a >
baabbbabaaaabba -> a
baabbbabaaaaba -> aabbbabaaaabba
baabbbabaaaaa -> aabbbabaaaaba

# < a,b | baabbbabaaabaaa=a >
baabbbabaaabaaa -> a

# < a,b | baabbbabaaabbba=a >
baabbbabaaabbba -> a
baabbbabaaabba -> aabbbabaaabbba
baabbbabaaaba -> aabbbabaaabba
baabbbabaaaa -> aabbbabaaaba

# < a,b | baabbbabaabaaaa=a >
baabbbabaabaaaa -> a

# < a,b | baabbbabaabaaba=a >
baabbbabaabaaba -> a
baabbbabaabaaa -> aabbbabaabaaba

# < a,b | baabbbabaababaa=a >
baabbbabaababaa -> a
baabbbabaabaa -> abbbabaababaa
baabbbabaaa -> abbbabaabaa

# < a,b | baabbbabaabbaaa=a >
baabbbabaabbaaa -> a

# < a,b | baabbbababaaaaa=a >
baabbbababaaaaa -> a

# < a,b | baabbbababaaaba=a >
baabbbababaaaba -> a
baabbbababaaaa -> aabbbababaaaba

# < a,b | baabbbababaabaa=a >
baabbbababaabaa -> a
baabbbababaaa -> abbbababaabaa

# < a,b | baabbbababaabba=a >
baabbbababaabba -> a
baabbbababaaba -> aabbbababaabba
baabbbababaaa -> aabbbababaaba

# < a,b | baabbbabababaaa=a >
baabbbabababaaa -> a

# < a,b | baabbbababbaaaa=a >
baabbbababbaaaa -> a

# < a,b | baabbbababbaaba=a >
baabbbababbaaba -> a
baabbbababbaaa -> aabbbababbaaba

# < a,b | baabbbababbbaaa=a >
baabbbababbbaaa -> a

# < a,b | baabbbabbaaaaaa=a >
baabbbabbaaaaaa -> a

# < a,b | baabbbabbaaaaba=a >
baabbbabbaaaaba -> a
baabbbabbaaaaa -> aabbbabbaaaaba

# < a,b | baabbbabbaaabaa=a >
baabbbabbaaabaa -> a
baabbbabbaaaa -> abbbabbaaabaa

# < a,b | baabbbabbaaabba=a >
baabbbabbaaabba -> a
baabbbabbaaaba -> aabbbabbaaabba
baabbbabbaaaa -> aabbbabbaaaba

# < a,b | baabbbabbaabaaa=a >
baabbbabbaabaaa -> a

# < a,b | baabbbabbabaaaa=a >
baabbbabbabaaaa -> a

# < a,b | baabbbabbabaaba=a >
baabbbabbabaaba -> a
baabbbabbabaaa -> aabbbabbabaaba

# < a,b | baabbbabbabbaaa=a >
baabbbabbabbaaa -> a

# < a,b | baabbbabbbaaaaa=a >
baabbbabbbaaaaa -> a

# < a,b | baabbbabbbaaaba=a >
baabbbabbbaaaba -> a
baabbbabbbaaaa -> aabbbabbbaaaba

# < a,b | baabbbabbbaabaa=a >
baabbbabbbaabaa -> a
baabbbabbbaaa -> abbbabbbaabaa

# < a,b | baabbbabbbaabba=a >
baabbbabbbaabba -> a
baabbbabbbaaba -> aabbbabbbaabba
baabbbabbbaaa -> aabbbabbbaaba

# < a,b | baabbbabbbabaaa=a >
baabbbabbbabaaa -> a

# < a,b | baabbbabbbbaaaa=a >
baabbbabbbbaaaa -> a

# < a,b | baabbbabbbbaaba=a >
baabbbabbbbaaba -> a
baabbbabbbbaaa -> aabbbabbbbaaba

# < a,b | baabbbabbbbbaaa=a >
baabbbabbbbbaaa -> a

# < a,b | baabbbbaaaaaaaa=a >
baabbbbaaaaaaaa -> a

# < a,b | baabbbbaaaaaaba=a >
baabbbbaaaaaaba -> a
baabbbbaaaaaaa -> aabbbbaaaaaaba

# < a,b | baabbbbaaaaabaa=a >
baabbbbaaaaabaa -> a
baabbbbaaaaaa -> abbbbaaaaabaa

# < a,b | baabbbbaaaaabba=a >
baabbbbaaaaabba -> a
baabbbbaaaaaba -> aabbbbaaaaabba
baabbbbaaaaaa -> aabbbbaaaaaba

# < a,b | baabbbbaaaabaaa=a >
baabbbbaaaabaaa -> a

# < a,b | baabbbbaaaabbba=a >
baabbbbaaaabbba -> a
baabbbbaaaabba -> aabbbbaaaabbba
baabbbbaaaaba -> aabbbbaaaabba
baabbbbaaaaa -> aabbbbaaaaba

# < a,b | baabbbbaaabaaaa=a >
baabbbbaaabaaaa -> a

# < a,b | baabbbbaaabaaba=a >
baabbbbaaabaaba -> a
baabbbbaaabaaa -> aabbbbaaabaaba

# < a,b | baabbbbaaababaa=a >
baabbbbaaababaa -> a
baabbbbaaabaa -> abbbbaaababaa
baabbbbaaaa -> abbbbaaabaa

# < a,b | baabbbbaaabbaaa=a >
baabbbbaaabbaaa -> a

# < a,b | baabbbbaaabbbba=a >
baabbbbaaabbbba -> a
baabbbbaaabbba -> aabbbbaaabbbba
baabbbbaaabba -> aabbbbaaabbba
baabbbbaaaba -> aabbbbaaabba
baabbbbaaaa -> aabbbbaaaba

# < a,b | baabbbbaabaaaaa=a >
baabbbbaabaaaaa -> a

# < a,b | baabbbbaabaaaba=a >
baabbbbaabaaaba -> a
baabbbbaabaaaa -> aabbbbaabaaaba

# < a,b | baabbbbaabaabaa=a >
baabbbbaabaabaa -> a
baabbbbaabaaa -> abbbbaabaabaa

# < a,b | baabbbbaabaabba=a >
baabbbbaabaabba -> a
baabbbbaabaaba -> aabbbbaabaabba
baabbbbaabaaa -> aabbbbaabaaba

# < a,b | baabbbbaababaaa=a >
baabbbbaababaaa -> a

# < a,b | baabbbbaabbaaaa=a >
baabbbbaabbaaaa -> a

# < a,b | baabbbbaabbaaba=a >
baabbbbaabbaaba -> a
baabbbbaabbaaa -> aabbbbaabbaaba

# < a,b | baabbbbaabbbaaa=a >
baabbbbaabbbaaa -> a

# < a,b | baabbbbabaaaaaa=a >
baabbbbabaaaaaa -> a

# < a,b | baabbbbabaaaaba=a >
baabbbbabaaaaba -> a
baabbbbabaaaaa -> aabbbbabaaaaba

# < a,b | baabbbbabaaabaa=a >
baabbbbabaaabaa -> a
baabbbbabaaaa -> abbbbabaaabaa

# < a,b | baabbbbabaaabba=a >
baabbbbabaaabba -> a
baabbbbabaaaba -> aabbbbabaaabba
baabbbbabaaaa -> aabbbbabaaaba

# < a,b | baabbbbabaabaaa=a >
baabbbbabaabaaa -> a

# < a,b | baabbbbabaabbba=a >
baabbbbabaabbba -> a
baabbbbabaabba -> aabbbbabaabbba
baabbbbabaaba -> aabbbbabaabba
baabbbbabaaa -> aabbbbabaaba

# < a,b | baabbbbababaaaa=a >
baabbbbababaaaa -> a

# < a,b | baabbbbababaaba=a >
baabbbbababaaba -> a
baabbbbababaaa -> aabbbbababaaba

# < a,b | baabbbbababbaaa=a >
baabbbbababbaaa -> a

# < a,b | baabbbbabbaaaaa=a >
baabbbbabbaaaaa -> a

# < a,b | baabbbbabbaaaba=a >
baabbbbabbaaaba -> a
baabbbbabbaaaa -> aabbbbabbaaaba

# < a,b | baabbbbabbaabaa=a >
baabbbbabbaabaa -> a
baabbbbabbaaa -> abbbbabbaabaa

# < a,b | baabbbbabbaabba=a >
baabbbbabbaabba -> a
baabbbbabbaaba -> aabbbbabbaabba
baabbbbabbaaa -> aabbbbabbaaba

# < a,b | baabbbbabbabaaa=a >
baabbbbabbabaaa -> a

# < a,b | baabbbbabbbaaaa=a >
baabbbbabbbaaaa -> a

# < a,b | baabbbbabbbaaba=a >
baabbbbabbbaaba -> a
baabbbbabbbaaa -> aabbbbabbbaaba

# < a,b | baabbbbabbbbaaa=a >
baabbbbabbbbaaa -> a

# < a,b | baabbbbbaaaaaaa=a >
baabbbbbaaaaaaa -> a

# < a,b | baabbbbbaaaaaba=a >
baabbbbbaaaaaba -> a
baabbbbbaaaaaa -> aabbbbbaaaaaba

# < a,b | baabbbbbaaaabaa=a >
baabbbbbaaaabaa -> a
baabbbbbaaaaa -> abbbbbaaaabaa

# < a,b | baabbbbbaaaabba=a >
baabbbbbaaaabba -> a
baabbbbbaaaaba -> aabbbbbaaaabba
baabbbbbaaaaa -> aabbbbbaaaaba

# < a,b | baabbbbbaaabaaa=a >
baabbbbbaaabaaa -> a

# < a,b | baabbbbbaaabbba=a >
baabbbbbaaabbba -> a
baabbbbbaaabba -> aabbbbbaaabbba
baabbbbbaaaba -> aabbbbbaaabba
baabbbbbaaaa -> aabbbbbaaaba

# < a,b | baabbbbbaabaaaa=a >
baabbbbbaabaaaa -> a

# < a,b | baabbbbbaabaaba=a >
baabbbbbaabaaba -> a
baabbbbbaabaaa -> aabbbbbaabaaba

# < a,b | baabbbbbaababaa=a >
baabbbbbaababaa -> a
baabbbbbaabaa -> abbbbbaababaa
baabbbbbaaa -> abbbbbaabaa

# < a,b | baabbbbbaabbaaa=a >
baabbbbbaabbaaa -> a

# < a,b | baabbbbbaabbbba=a >
baabbbbbaabbbba -> a
baabbbbbaabbba -> aabbbbbaabbbba
baabbbbbaabba -> aabbbbbaabbba
baabbbbbaaba -> aabbbbbaabba
baabbbbbaaa -> aabbbbbaaba

# < a,b | baabbbbbabaaaaa=a >
baabbbbbabaaaaa -> a

# < a,b | baabbbbbabaaaba=a >
baabbbbbabaaaba -> a
baabbbbbabaaaa -> aabbbbbabaaaba

# < a,b | baabbbbbabaabaa=a >
baabbbbbabaabaa -> a
baabbbbbabaaa -> abbbbbabaabaa

# < a,b | baabbbbbabaabba=a >
baabbbbbabaabba -> a
baabbbbbabaaba -> aabbbbbabaabba
baabbbbbabaaa -> aabbbbbabaaba

# < a,b | baabbbbbababaaa=a >
baabbbbbababaaa -> a

# < a,b | baabbbbbabbaaaa=a >
baabbbbbabbaaaa -> a

# < a,b | baabbbbbabbaaba=a >
baabbbbbabbaaba -> a
baabbbbbabbaaa -> aabbbbbabbaaba

# < a,b | baabbbbbabbbaaa=a >
baabbbbbabbbaaa -> a

# < a,b | baabbbbbbaaaaaa=a >
baabbbbbbaaaaaa -> a

# < a,b | baabbbbbbaaaaba=a >
baabbbbbbaaaaba -> a
baabbbbbbaaaaa -> aabbbbbbaaaaba

# < a,b | baabbbbbbaaabaa=a >
baabbbbbbaaabaa -> a
baabbbbbbaaaa -> abbbbbbaaabaa

# < a,b | baabbbbbbaaabba=a >
baabbbbbbaaabba -> a
baabbbbbbaaaba -> aabbbbbbaaabba
baabbbbbbaaaa -> aabbbbbbaaaba

# < a,b | baabbbbbbaabaaa=a >
baabbbbbbaabaaa -> a

# < a,b | baabbbbbbaabbba=a >
baabbbbbbaabbba -> a
baabbbbbbaabba -> aabbbbbbaabbba
baabbbbbbaaba -> aabbbbbbaabba
baabbbbbbaaa -> aabbbbbbaaba

# < a,b | baabbbbbbabaaaa=a >
baabbbbbbabaaaa -> a

# < a,b | baabbbbbbabaaba=a >
baabbbbbbabaaba -> a
baabbbbbbabaaa -> aabbbbbbabaaba

# < a,b | baabbbbbbabbaaa=a >
baabbbbbbabbaaa -> a

# < a,b | baabbbbbbbaaaaa=a >
baabbbbbbbaaaaa -> a

# < a,b | baabbbbbbbaaaba=a >
baabbbbbbbaaaba -> a
baabbbbbbbaaaa -> aabbbbbbbaaaba

# < a,b | baabbbbbbbaabaa=a >
baabbbbbbbaabaa -> a
baabbbbbbbaaa -> abbbbbbbaabaa

# < a,b | baabbbbbbbaabba=a >
baabbbbbbbaabba -> a
baabbbbbbbaaba -> aabbbbbbbaabba
baabbbbbbbaaa -> aabbbbbbbaaba

# < a,b | baabbbbbbbabaaa=a >
baabbbbbbbabaaa -> a

# < a,b | baabbbbbbbbaaaa=a >
baabbbbbbbbaaaa -> a

# < a,b | baabbbbbbbbaaba=a >
baabbbbbbbbaaba -> a
baabbbbbbbbaaa -> aabbbbbbbbaaba

# < a,b | baabbbbbbbbbaaa=a >
baabbbbbbbbbaaa -> a

# < a,b | baabbbbbbbbbbba=a >
baabbbbbbbbbbba -> a
baabbbbbbbbbba -> aabbbbbbbbbbba
baabbbbbbbbba -> aabbbbbbbbbba
baabbbbbbbba -> aabbbbbbbbba
baabbbbbbba -> aabbbbbbbba
baabbbbbba -> aabbbbbbba
baabbbbba -> aabbbbbba
baabbbba -> aabbbbba
baabbba -> aabbbba
baabba -> aabbba
baaba -> aabba
baaa -> aaba

# < a,b | babaaaaaaaaaaaa=a >
babaaaaaaaaaaaa -> a

# < a,b | babaaaaaaaaaaba=a >
babaaaaaaaaaaba -> a
babaaaaaaaaaaa -> abaaaaaaaaaaba

# < a,b | babaaaaaaaaabaa=a >
babaaaaaaaaabaa -> a

# < a,b | babaaaaaaaaabba=a >
babaaaaaaaaabba -> a
babaaaaaaaaaba -> abaaaaaaaaabba
babaaaaaaaaaa -> abaaaaaaaaaba

# < a,b | babaaaaaaaabaaa=a >
babaaaaaaaabaaa -> a

# < a,b | babaaaaaaaababa=a >
babaaaaaaaababa -> a
babaaaaaaaabaa -> abaaaaaaaababa
babaaaaaaaaa -> aaaaaaaababa

# < a,b | babaaaaaaaabbaa=a >
babaaaaaaaabbaa -> a

# < a,b | babaaaaaaaabbba=a >
babaaaaaaaabbba -> a
babaaaaaaaabba -> abaaaaaaaabbba
babaaaaaaaaba -> abaaaaaaaabba
babaaaaaaaaa -> abaaaaaaaaba

# < a,b | babaaaaaaabaaaa=a >
babaaaaaaabaaaa -> a

# < a,b | babaaaaaaabaaba=a >
babaaaaaaabaaba -> a
babaaaaaaabaaa -> abaaaaaaabaaba

# < a,b | babaaaaaaababaa=a >
babaaaaaaababaa -> a
babaaaaaaaa -> aaaaaababaa

# < a,b | babaaaaaaabbaaa=a >
babaaaaaaabbaaa -> a

# < a,b | babaaaaaaabbaba=a >
babaaaaaaabbaba -> a
babaaaaaaabbaa -> abaaaaaaabbaba
babaaaaaaaba -> aaaaaaabbaba
babaaaaaaaa -> aaaaaaabbaa

# < a,b | babaaaaaaabbbaa=a >
babaaaaaaabbbaa -> a

# < a,b | babaaaaaaabbbba=a >
babaaaaaaabbbba -> a
babaaaaaaabbba -> abaaaaaaabbbba
babaaaaaaabba -> abaaaaaaabbba
babaaaaaaaba -> abaaaaaaabba
babaaaaaaaa -> abaaaaaaaba

# < a,b | babaaaaaabaaaaa=a >
babaaaaaabaaaaa -> a

# < a,b | babaaaaaabaaaba=a >
babaaaaaabaaaba -> a
babaaaaaabaaaa -> abaaaaaabaaaba

# < a,b | babaaaaaabaabaa=a >
babaaaaaabaabaa -> a

# < a,b | babaaaaaabaabba=a >
babaaaaaabaabba -> a
babaaaaaabaaba -> abaaaaaabaabba
babaaaaaabaaa -> abaaaaaabaaba

# < a,b | babaaaaaababaaa=a >
babaaaaaababaaa -> a
babaaaaaaa -> aaaababaaa

# < a,b | babaaaaaababbaa=a >
babaaaaaababbaa -> a

# < a,b | babaaaaaabbaaaa=a >
babaaaaaabbaaaa -> a

# < a,b | babaaaaaabbaaba=a >
babaaaaaabbaaba -> a
babaaaaaabbaaa -> abaaaaaabbaaba

# < a,b | babaaaaaabbbaaa=a >
babaaaaaabbbaaa -> a

# < a,b | babaaaaaabbbbaa=a >
babaaaaaabbbbaa -> a

# < a,b | babaaaaaabbbbba=a >
babaaaaaabbbbba -> a
babaaaaaabbbba -> abaaaaaabbbbba
babaaaaaabbba -> abaaaaaabbbba
babaaaaaabba -> abaaaaaabbba
babaaaaaaba -> abaaaaaabba
babaaaaaaa -> abaaaaaaba

# < a,b | babaaaaabaaaaaa=a >
babaaaaabaaaaaa -> a

# < a,b | babaaaaabaaaaba=a >
babaaaaabaaaaba -> a
babaaaaabaaaaa -> abaaaaabaaaaba

# < a,b | babaaaaabaaabaa=a >
babaaaaabaaabaa -> a

# < a,b | babaaaaabaaabba=a >
babaaaaabaaabba -> a
babaaaaabaaaba -> abaaaaabaaabba
babaaaaabaaaa -> abaaaaabaaaba

# < a,b | babaaaaabaabaaa=a >
babaaaaabaabaaa -> a

# < a,b | babaaaaabaababa=a >
babaaaaabaababa -> a
babaaaaabaabaa -> abaaaaabaababa
babaaaaabaaa -> aaaaabaababa

# < a,b | babaaaaabaabbaa=a >
babaaaaabaabbaa -> a

# < a,b | babaaaaabaabbba=a >
babaaaaabaabbba -> a
babaaaaabaabba -> abaaaaabaabbba
babaaaaabaaba -> abaaaaabaabba
babaaaaabaaa -> abaaaaabaaba

# < a,b | babaaaaababaaaa=a >
babaaaaababaaaa -> a
babaaaaaa -> aababaaaa

# < a,b | babaaaaabababaa=a >
babaaaaabababaa -> a
babaaaaabaa -> aaaabababaa

# < a,b | babaaaaababbaaa=a >
babaaaaababbaaa -> a

# < a,b | babaaaaababbaba=a >
babaaaaababbaba -> a
babaaaaababbaa -> abaaaaababbaba
babaaaaababa -> aaaaababbaba
babaaaaabaa -> aaaaababbaa
babaaaaaa -> aaaaababa

# < a,b | babaaaaababbbaa=a >
babaaaaababbbaa -> a

# < a,b | babaaaaabbaaaaa=a >
babaaaaabbaaaaa -> a

# < a,b | babaaaaabbaaaba=a >
babaaaaabbaaaba -> a
babaaaaabbaaaa -> abaaaaabbaaaba

# < a,b | babaaaaabbaabaa=a >
babaaaaabbaabaa -> a

# < a,b | babaaaaabbaabba=a >
babaaaaabbaabba -> a
babaaaaabbaaba -> abaaaaabbaabba
babaaaaabbaaa -> abaaaaabbaaba

# < a,b | babaaaaabbabbaa=a >
babaaaaabbabbaa -> a

# < a,b | babaaaaabbbaaaa=a >
babaaaaabbbaaaa -> a

# < a,b | babaaaaabbbaaba=a >
babaaaaabbbaaba -> a
babaaaaabbbaaa -> abaaaaabbbaaba

# < a,b | babaaaaabbbbaaa=a >
babaaaaabbbbaaa -> a

# < a,b | babaaaaabbbbbaa=a >
babaaaaabbbbbaa -> a

# < a,b | babaaaaabbbbbba=a >
babaaaaabbbbbba -> a
babaaaaabbbbba -> abaaaaabbbbbba
babaaaaabbbba -> abaaaaabbbbba
babaaaaabbba -> abaaaaabbbba
babaaaaabba -> abaaaaabbba
babaaaaaba -> abaaaaabba
babaaaaaa -> abaaaaaba

# < a,b | babaaaabaaaaaaa=a >
babaaaabaaaaaaa -> a

# < a,b | babaaaabaaaaaba=a >
babaaaabaaaaaba -> a
babaaaabaaaaaa -> abaaaabaaaaaba

# < a,b | babaaaabaaaabaa=a >
babaaaabaaaabaa -> a

# < a,b | babaaaabaaaabba=a >
babaaaabaaaabba -> a
babaaaabaaaaba -> abaaaabaaaabba
babaaaabaaaaa -> abaaaabaaaaba

# < a,b | babaaaabaaabaaa=a >
babaaaabaaabaaa -> a

# < a,b | babaaaabaaababa=a >
babaaaabaaababa -> a
babaaaabaaabaa -> abaaaabaaababa
babaaaabaaaa -> aaaabaaababa

# < a,b | babaaaabaaabbaa=a >
babaaaabaaabbaa -> a

# < a,b | babaaaabaaabbba=a >
babaaaabaaabbba -> a
babaaaabaaabba -> abaaaabaaabbba
babaaaabaaaba -> abaaaabaaabba
babaaaabaaaa -> abaaaabaaaba

# < a,b | babaaaabaabaaaa=a >
babaaaabaabaaaa -> a

# < a,b | babaaaabaabaaba=a >
babaaaabaabaaba -> a
babaaaabaabaaa -> abaaaabaabaaba

# < a,b | babaaaabaababaa=a >
babaaaabaababaa -> a
babaaaabaaa -> aaabaababaa

# < a,b | babaaaabaabbaaa=a >
babaaaabaabbaaa -> a

# < a,b | babaaaabaabbaba=a >
babaaaabaabbaba -> a
babaaaabaabbaa -> abaaaabaabbaba
babaaaabaaba -> aaaabaabbaba
babaaaabaaa -> aaaabaabbaa

# < a,b | babaaaabaabbbaa=a >
babaaaabaabbbaa -> a

# < a,b | babaaaabaabbbba=a >
babaaaabaabbbba -> a
babaaaabaabbba -> abaaaabaabbbba
babaaaabaabba -> abaaaabaabbba
babaaaabaaba -> abaaaabaabba
babaaaabaaa -> abaaaabaaba

# < a,b | babaaaababaaaaa=a >
babaaaababaaaaa -> a

# < a,b | babaaaababaabaa=a >
babaaaababaabaa -> a

# < a,b | babaaaabababaaa=a >
babaaaabababaaa -> a
babaaaabaa -> aabababaaa

# < a,b | babaaaabababbaa=a >
babaaaabababbaa -> a

# < a,b | babaaaababbaaaa=a >
babaaaababbaaaa -> a

# < a,b | babaaaababbaaba=a >
babaaaababbaaba -> a
babaaaababbaaa -> abaaaababbaaba

# < a,b | babaaaababbbaaa=a >
babaaaababbbaaa -> a

# < a,b | babaaaababbbbaa=a >
babaaaababbbbaa -> a

# < a,b | babaaaabbaaaaaa=a >
babaaaabbaaaaaa -> a

# < a,b | babaaaabbaaaaba=a >
babaaaabbaaaaba -> a
babaaaabbaaaaa -> abaaaabbaaaaba

# < a,b | babaaaabbaaabaa=a >
babaaaabbaaabaa -> a

# < a,b | babaaaabbaaabba=a >
babaaaabbaaabba -> a
babaaaabbaaaba -> abaaaabbaaabba
babaaaabbaaaa -> abaaaabbaaaba

# < a,b | babaaaabbaabaaa=a >
babaaaabbaabaaa -> a

# < a,b | babaaaabbaababa=a >
babaaaabbaababa -> a
babaaaabbaabaa -> abaaaabbaababa
babaaaabbaaa -> aaaabbaababa

# < a,b | babaaaabbaabbaa=a >
babaaaabbaabbaa -> a

# < a,b | babaaaabbaabbba=a >
babaaaabbaabbba -> a
babaaaabbaabba -> abaaaabbaabbba
babaaaabbaaba -> abaaaabbaabba
babaaaabbaaa -> abaaaabbaaba

# < a,b | babaaaabbababaa=a >
babaaaabbababaa -> a
babaaaabbaa -> aaabbababaa

# < a,b | babaaaabbabbaaa=a >
babaaaabbabbaaa -> a

# < a,b | babaaaabbabbaba=a >
babaaaabbabbaba -> a
babaaaabbabbaa -> abaaaabbabbaba
babaaaabbaba -> aaaabbabbaba
babaaaabbaa -> aaaabbabbaa
babaaaaba -> aaaabbaba
babaaaaa -> aaaabbaa

# < a,b | babaaaabbabbbaa=a >
babaaaabbabbbaa -> a

# < a,b | babaaaabbbaaaaa=a >
babaaaabbbaaaaa -> a

# < a,b | babaaaabbbaaaba=a >
babaaaabbbaaaba -> a
babaaaabbbaaaa -> abaaaabbbaaaba

# < a,b | babaaaabbbaabaa=a >
babaaaabbbaabaa -> a

# < a,b | babaaaabbbaabba=a >
babaaaabbbaabba -> a
babaaaabbbaaba -> abaaaabbbaabba
babaaaabbbaaa -> abaaaabbbaaba

# < a,b | babaaaabbbabbaa=a >
babaaaabbbabbaa -> a

# < a,b | babaaaabbbbaaaa=a >
babaaaabbbbaaaa -> a

# < a,b | babaaaabbbbaaba=a >
babaaaabbbbaaba -> a
babaaaabbbbaaa -> abaaaabbbbaaba

# < a,b | babaaaabbbbbaaa=a >
babaaaabbbbbaaa -> a

# < a,b | babaaaabbbbbbaa=a >
babaaaabbbbbbaa -> a

# < a,b | babaaaabbbbbbba=a >
babaaaabbbbbbba -> a
babaaaabbbbbba -> abaaaabbbbbbba
babaaaabbbbba -> abaaaabbbbbba
babaaaabbbba -> abaaaabbbbba
babaaaabbba -> abaaaabbbba
babaaaabba -> abaaaabbba
babaaaaba -> abaaaabba
babaaaaa -> abaaaaba

# < a,b | babaaabaaaaaaaa=a >
babaaabaaaaaaaa -> a

# < a,b | babaaabaaaaaaba=a >
babaaabaaaaaaba -> a
babaaabaaaaaaa -> abaaabaaaaaaba

# < a,b | babaaabaaaaabaa=a >
babaaabaaaaabaa -> a

# < a,b | babaaabaaaaabba=a >
babaaabaaaaabba -> a
babaaabaaaaaba -> abaaabaaaaabba
babaaabaaaaaa -> abaaabaaaaaba

# < a,b | babaaabaaaabaaa=a >
babaaabaaaabaaa -> a

# < a,b | babaaabaaaababa=a >
babaaabaaaababa -> a
babaaabaaaabaa -> abaaabaaaababa
babaaabaaaaa -> aaabaaaababa

# < a,b | babaaabaaaabbaa=a >
babaaabaaaabbaa -> a

# < a,b | babaaabaaaabbba=a >
babaaabaaaabbba -> a
babaaabaaaabba -> abaaabaaaabbba
babaaabaaaaba -> abaaabaaaabba
babaaabaaaaa -> abaaabaaaaba

# < a,b | babaaabaaabaaaa=a >
babaaabaaabaaaa -> a

# < a,b | babaaabaaabaaba=a >
babaaabaaabaaba -> a
babaaabaaabaaa -> abaaabaaabaaba

# < a,b | babaaabaaababaa=a >
babaaabaaababaa -> a
babaaabaaaa -> aabaaababaa

# < a,b | babaaabaaabbaaa=a >
babaaabaaabbaaa -> a

# < a,b | babaaabaaabbaba=a >
babaaabaaabbaba -> a
babaaabaaabbaa -> abaaabaaabbaba
babaaabaaaba -> aaabaaabbaba
babaaabaaaa -> aaabaaabbaa

# < a,b | babaaabaaabbbaa=a >
babaaabaaabbbaa -> a

# < a,b | babaaabaaabbbba=a >
babaaabaaabbbba -> a
babaaabaaabbba -> abaaabaaabbbba
babaaabaaabba -> abaaabaaabbba
babaaabaaaba -> abaaabaaabba
babaaabaaaa -> abaaabaaaba

# < a,b | babaaabaabaaaaa=a >
babaaabaabaaaaa -> a

# < a,b | babaaabaabaaaba=a >
babaaabaabaaaba -> a
babaaabaabaaaa -> abaaabaabaaaba

# < a,b | babaaabaabaabaa=a >
babaaabaabaabaa -> a

# < a,b | babaaabaabaabba=a >
babaaabaabaabba -> a
babaaabaabaaba -> abaaabaabaabba
babaaabaabaaa -> abaaabaabaaba

# < a,b | babaaabaababaaa=a >
babaaabaababaaa -> a
babaaabaaa -> abaababaaa

# < a,b | babaaabaababbaa=a >
babaaabaababbaa -> a

# < a,b | babaaabaabbaaaa=a >
babaaabaabbaaaa -> a

# < a,b | babaaabaabbaaba=a >
babaaabaabbaaba -> a
babaaabaabbaaa -> abaaabaabbaaba

# < a,b | babaaabaabbbaaa=a >
babaaabaabbbaaa -> a

# < a,b | babaaabaabbbbaa=a >
babaaabaabbbbaa -> a

# < a,b | babaaabaabbbbba=a >
babaaabaabbbbba -> a
babaaabaabbbba -> abaaabaabbbbba
babaaabaabbba -> abaaabaabbbba
babaaabaabba -> abaaabaabbba
babaaabaaba -> abaaabaabba
babaaabaaa -> abaaabaaba

# < a,b | babaaababaaaaaa=a >
babaaababaaaaaa -> a

# < a,b | babaaababaaaaba=a >
babaaababaaaaba -> a
babaaababaaaaa -> abaaababaaaaba

# < a,b | babaaababaaabaa=a >
babaaababaaabaa -> a

# < a,b | babaaababaabaaa=a >
babaaababaabaaa -> a

# < a,b | babaaababaabbaa=a >
babaaababaabbaa -> a

# < a,b | babaaabababaaaa=a >
babaaabababaaaa -> a

# < a,b | babaaababababaa=a >
babaaababababaa -> a
babaaababaa -> aababababaa
babaaaa -> aababaa

# < a,b | babaaabababbaaa=a >
babaaabababbaaa -> a

# < a,b | babaaabababbbaa=a >
babaaabababbbaa -> a

# < a,b | babaaababbaaaaa=a >
babaaababbaaaaa -> a

# < a,b | babaaababbaaaba=a >
babaaababbaaaba -> a
babaaababbaaaa -> abaaababbaaaba

# < a,b | babaaababbaabaa=a >
babaaababbaabaa -> a

# < a,b | babaaababbaabba=a >
babaaababbaabba -> a
babaaababbaaba -> abaaababbaabba
babaaababbaaa -> abaaababbaaba

# < a,b | babaaababbabbaa=a >
babaaababbabbaa -> a

# < a,b | babaaababbbaaaa=a >
babaaababbbaaaa -> a

# < a,b | babaaababbbaaba=a >
babaaababbbaaba -> a
babaaababbbaaa -> abaaababbbaaba

# < a,b | babaaababbbbaaa=a >
babaaababbbbaaa -> a

# < a,b | babaaababbbbbaa=a >
babaaababbbbbaa -> a

# < a,b | babaaabbaaaaaaa=a >
babaaabbaaaaaaa -> a

# < a,b | babaaabbaaaaaba=a >
babaaabbaaaaaba -> a
babaaabbaaaaaa -> abaaabbaaaaaba

# < a,b | babaaabbaaaabaa=a >
babaaabbaaaabaa -> a

# < a,b | babaaabbaaaabba=a >
babaaabbaaaabba -> a
babaaabbaaaaba -> abaaabbaaaabba
babaaabbaaaaa -> abaaabbaaaaba

# < a,b | babaaabbaaabaaa=a >
babaaabbaaabaaa -> a

# < a,b | babaaabbaaababa=a >
babaaabbaaababa -> a
babaaabbaaabaa -> abaaabbaaababa
babaaabbaaaa -> aaabbaaababa

# < a,b | babaaabbaaabbaa=a >
babaaabbaaabbaa -> a

# < a,b | babaaabbaaabbba=a >
babaaabbaaabbba -> a
babaaabbaaabba -> abaaabbaaabbba
babaaabbaaaba -> abaaabbaaabba
babaaabbaaaa -> abaaabbaaaba

# < a,b | babaaabbaabaaaa=a >
babaaabbaabaaaa -> a

# < a,b | babaaabbaabaaba=a >
babaaabbaabaaba -> a
babaaabbaabaaa -> abaaabbaabaaba

# < a,b | babaaabbaababaa=a >
babaaabbaababaa -> a
babaaabbaaa -> aabbaababaa

# < a,b | babaaabbaabbaaa=a >
babaaabbaabbaaa -> a

# < a,b | babaaabbaabbaba=a >
babaaabbaabbaba -> a
babaaabbaabbaa -> abaaabbaabbaba
babaaabbaaba -> aaabbaabbaba
babaaabbaaa -> aaabbaabbaa

# < a,b | babaaabbaabbbaa=a >
babaaabbaabbbaa -> a

# < a,b | babaaabbaabbbba=a >
babaaabbaabbbba -> a
babaaabbaabbba -> abaaabbaabbbba
babaaabbaabba -> abaaabbaabbba
babaaabbaaba -> abaaabbaabba
babaaabbaaa -> abaaabbaaba

# < a,b | babaaabbabaaaaa=a >
babaaabbabaaaaa -> a

# < a,b | babaaabbabaaaba=a >
babaaabbabaaaba -> a
babaaabbabaaaa -> abaaabbabaaaba

# < a,b | babaaabbabaabaa=a >
babaaabbabaabaa -> a

# < a,b | babaaabbababaaa=a >
babaaabbababaaa -> a
babaaabbaa -> abbababaaa

# < a,b | babaaabbababbaa=a >
babaaabbababbaa -> a

# < a,b | babaaabbabbaaaa=a >
babaaabbabbaaaa -> a

# < a,b | babaaabbabbaaba=a >
babaaabbabbaaba -> a
babaaabbabbaaa -> abaaabbabbaaba

# < a,b | babaaabbabbbaaa=a >
babaaabbabbbaaa -> a

# < a,b | babaaabbabbbbaa=a >
babaaabbabbbbaa -> a

# < a,b | babaaabbbaaaaaa=a >
babaaabbbaaaaaa -> a

# < a,b | babaaabbbaaaaba=a >
babaaabbbaaaaba -> a
babaaabbbaaaaa -> abaaabbbaaaaba

# < a,b | babaaabbbaaabaa=a >
babaaabbbaaabaa -> a

# < a,b | babaaabbbaaabba=a >
babaaabbbaaabba -> a
babaaabbbaaaba -> abaaabbbaaabba
babaaabbbaaaa -> abaaabbbaaaba

# < a,b | babaaabbbaabaaa=a >
babaaabbbaabaaa -> a

# < a,b | babaaabbbaababa=a >
babaaabbbaababa -> a
babaaabbbaabaa -> abaaabbbaababa
babaaabbbaaa -> aaabbbaababa

# < a,b | babaaabbbaabbaa=a >
babaaabbbaabbaa -> a

# < a,b | babaaabbbaabbba=a >
babaaabbbaabbba -> a
babaaabbbaabba -> abaaabbbaabbba
babaaabbbaaba -> abaaabbbaabba
babaaabbbaaa -> abaaabbbaaba

# < a,b | babaaabbbabaaaa=a >
babaaabbbabaaaa -> a

# < a,b | babaaabbbababaa=a >
babaaabbbababaa -> a
babaaabbbaa -> aabbbababaa

# < a,b | babaaabbbabbaaa=a >
babaaabbbabbaaa -> a

# < a,b | babaaabbbabbbaa=a >
babaaabbbabbbaa -> a

# < a,b | babaaabbbbaaaaa=a >
babaaabbbbaaaaa -> a

# < a,b | babaaabbbbaaaba=a >
babaaabbbbaaaba -> a
babaaabbbbaaaa -> abaaabbbbaaaba

# < a,b | babaaabbbbaabaa=a >
babaaabbbbaabaa -> a

# < a,b | babaaabbbbaabba=a >
babaaabbbbaabba -> a
babaaabbbbaaba -> abaaabbbbaabba
babaaabbbbaaa -> abaaabbbbaaba

# < a,b | babaaabbbbabbaa=a >
babaaabbbbabbaa -> a

# < a,b | babaaabbbbbaaaa=a >
babaaabbbbbaaaa -> a

# < a,b | babaaabbbbbaaba=a >
babaaabbbbbaaba -> a
babaaabbbbbaaa -> abaaabbbbbaaba

# < a,b | babaaabbbbbbaaa=a >
babaaabbbbbbaaa -> a

# < a,b | babaaabbbbbbbaa=a >
babaaabbbbbbbaa -> a

# < a,b | babaaabbbbbbbba=a >
babaaabbbbbbbba -> a
babaaabbbbbbba -> abaaabbbbbbbba
babaaabbbbbba -> abaaabbbbbbba
babaaabbbbba -> abaaabbbbbba
babaaabbbba -> abaaabbbbba
babaaabbba -> abaaabbbba
babaaabba -> abaaabbba
babaaaba -> abaaabba
babaaaa -> abaaaba

# < a,b | babaabaaaaaaaaa=a >
babaabaaaaaaaaa -> a

# < a,b | babaabaaaaaaaba=a >
babaabaaaaaaaba -> a
babaabaaaaaaaa -> abaabaaaaaaaba

# < a,b | babaabaaaaaabaa=a >
babaabaaaaaabaa -> a

# < a,b | babaabaaaaaabba=a >
babaabaaaaaabba -> a
babaabaaaaaaba -> abaabaaaaaabba
babaabaaaaaaa -> abaabaaaaaaba

# < a,b | babaabaaaaabaaa=a >
babaabaaaaabaaa -> a

# < a,b | babaabaaaaababa=a >
babaabaaaaababa -> a
babaabaaaaabaa -> abaabaaaaababa
babaabaaaaaa -> aabaaaaababa

# < a,b | babaabaaaaabbaa=a >
babaabaaaaabbaa -> a

# < a,b | babaabaaaaabbba=a >
babaabaaaaabbba -> a
babaabaaaaabba -> abaabaaaaabbba
babaabaaaaaba -> abaabaaaaabba
babaabaaaaaa -> abaabaaaaaba

# < a,b | babaabaaaabaaaa=a >
babaabaaaabaaaa -> a

# < a,b | babaabaaaabaaba=a >
babaabaaaabaaba -> a
babaabaaaabaaa -> abaabaaaabaaba

# < a,b | babaabaaaababaa=a >
babaabaaaababaa -> a
babaabaaaaa -> abaaaababaa

# < a,b | babaabaaaabbaaa=a >
babaabaaaabbaaa -> a

# < a,b | babaabaaaabbaba=a >
babaabaaaabbaba -> a
babaabaaaabbaa -> abaabaaaabbaba
babaabaaaaba -> aabaaaabbaba
babaabaaaaa -> aabaaaabbaa

# < a,b | babaabaaaabbbaa=a >
babaabaaaabbbaa -> a

# < a,b | babaabaaaabbbba=a >
babaabaaaabbbba -> a
babaabaaaabbba -> abaabaaaabbbba
babaabaaaabba -> abaabaaaabbba
babaabaaaaba -> abaabaaaabba
babaabaaaaa -> abaabaaaaba

# < a,b | babaabaaabaaaaa=a >
babaabaaabaaaaa -> a

# < a,b | babaabaaabaaaba=a >
babaabaaabaaaba -> a
babaabaaabaaaa -> abaabaaabaaaba

# < a,b | babaabaaabaabaa=a >
babaabaaabaabaa -> a

# < a,b | babaabaaabaabba=a >
babaabaaabaabba -> a
babaabaaabaaba -> abaabaaabaabba
babaabaaabaaa -> abaabaaabaaba

# < a,b | babaabaaababaaa=a >
babaabaaababaaa -> a

# < a,b | babaabaaababbaa=a >
babaabaaababbaa -> a

# < a,b | babaabaaabbaaaa=a >
babaabaaabbaaaa -> a

# < a,b | babaabaaabbaaba=a >
babaabaaabbaaba -> a
babaabaaabbaaa -> abaabaaabbaaba

# < a,b | babaabaaabbbaaa=a >
babaabaaabbbaaa -> a

# < a,b | babaabaaabbbbaa=a >
babaabaaabbbbaa -> a

# < a,b | babaabaaabbbbba=a >
babaabaaabbbbba -> a
babaabaaabbbba -> abaabaaabbbbba
babaabaaabbba -> abaabaaabbbba
babaabaaabba -> abaabaaabbba
babaabaaaba -> abaabaaabba
babaabaaaa -> abaabaaaba

# < a,b | babaabaabaaaaaa=a >
babaabaabaaaaaa -> a

# < a,b | babaabaabaaaaba=a >
babaabaabaaaaba -> a
babaabaabaaaaa -> abaabaabaaaaba

# < a,b | babaabaabaaabaa=a >
babaabaabaaabaa -> a

# < a,b | babaabaabaaabba=a >
babaabaabaaabba -> a
babaabaabaaaba -> abaabaabaaabba
babaabaabaaaa -> abaabaabaaaba

# < a,b | babaabaabaabaaa=a >
babaabaabaabaaa -> a

# < a,b | babaabaabaababa=a >
babaabaabaababa -> a
babaabaabaabaa -> abaabaabaababa
babaabaabaaa -> aabaabaababa

# < a,b | babaabaabaabbaa=a >
babaabaabaabbaa -> a

# < a,b | babaabaabaabbba=a >
babaabaabaabbba -> a
babaabaabaabba -> abaabaabaabbba
babaabaabaaba -> abaabaabaabba
babaabaabaaa -> abaabaabaaba

# < a,b | babaabaababaaaa=a >
babaabaababaaaa -> a

# < a,b | babaabaababaaba=a >
babaabaababaaba -> a
babaabaababaaa -> abaabaababaaba
babaabaaa -> aababaaba

# < a,b | babaabaabababaa=a >
babaabaabababaa -> a
babaabaabaa -> abaabababaa

# < a,b | babaabaababbaaa=a >
babaabaababbaaa -> a

# < a,b | babaabaababbaba=a >
babaabaababbaba -> a
babaabaababbaa -> abaabaababbaba
babaabaababa -> aabaababbaba
babaabaabaa -> aabaababbaa
babaabaaa -> aabaababa

# < a,b | babaabaababbbaa=a >
babaabaababbbaa -> a

# < a,b | babaabaabbaaaaa=a >
babaabaabbaaaaa -> a

# < a,b | babaabaabbaaaba=a >
babaabaabbaaaba -> a
babaabaabbaaaa -> abaabaabbaaaba

# < a,b | babaabaabbaabaa=a >
babaabaabbaabaa -> a

# < a,b | babaabaabbaabba=a >
babaabaabbaabba -> a
babaabaabbaaba -> abaabaabbaabba
babaabaabbaaa -> abaabaabbaaba

# < a,b | babaabaabbabaaa=a >
babaabaabbabaaa -> a

# < a,b | babaabaabbabbaa=a >
babaabaabbabbaa -> a

# < a,b | babaabaabbbaaaa=a >
babaabaabbbaaaa -> a

# < a,b | babaabaabbbaaba=a >
babaabaabbbaaba -> a
babaabaabbbaaa -> abaabaabbbaaba

# < a,b | babaabaabbbbaaa=a >
babaabaabbbbaaa -> a

# < a,b | babaabaabbbbbaa=a >
babaabaabbbbbaa -> a

# < a,b | babaabaabbbbbba=a >
babaabaabbbbbba -> a
babaabaabbbbba -> abaabaabbbbbba
babaabaabbbba -> abaabaabbbbba
babaabaabbba -> abaabaabbbba
babaabaabba -> abaabaabbba
babaabaaba -> abaabaabba
babaabaaa -> abaabaaba

# < a,b | babaababaaaaaaa=a >
babaababaaaaaaa -> a

# < a,b | babaababaaaaaba=a >
babaababaaaaaba -> a
babaababaaaaaa -> abaababaaaaaba

# < a,b | babaababaaaabaa=a >
babaababaaaabaa -> a

# < a,b | babaababaaaabba=a >
babaababaaaabba -> a
babaababaaaaba -> abaababaaaabba
babaababaaaaa -> abaababaaaaba

# < a,b | babaababaaabaaa=a >
babaababaaabaaa -> a

# < a,b | babaababaaababa=a >
babaababaaababa -> a
babaababaaabaa -> abaababaaababa
babaababaaaa -> aababaaababa

# < a,b | babaababaaabbaa=a >
babaababaaabbaa -> a

# < a,b | babaababaaabbba=a >
babaababaaabbba -> a
babaababaaabba -> abaababaaabbba
babaababaaaba -> abaababaaabba
babaababaaaa -> abaababaaaba

# < a,b | babaababaabaaaa=a >
babaababaabaaaa -> a

# < a,b | babaababaabaaba=a >
babaababaabaaba -> a
babaababaabaaa -> abaababaabaaba

# < a,b | babaababaababaa=a >
babaababaababaa -> a
babaaa -> ababaa

# < a,b | babaababaabbaaa=a >
babaababaabbaaa -> a

# < a,b | babaababaabbbaa=a >
babaababaabbbaa -> a

# < a,b | babaabababaaaaa=a >
babaabababaaaaa -> a

# < a,b | babaabababaaaba=a >
babaabababaaaba -> a
babaabababaaaa -> abaabababaaaba

# < a,b | babaabababaabaa=a >
babaabababaabaa -> a

# < a,b | babaababababaaa=a >
babaababababaaa -> a

# < a,b | babaababababbaa=a >
babaababababbaa -> a

# < a,b | babaabababbaaaa=a >
babaabababbaaaa -> a

# < a,b | babaabababbaaba=a >
babaabababbaaba -> a
babaabababbaaa -> abaabababbaaba

# < a,b | babaabababbbaaa=a >
babaabababbbaaa -> a

# < a,b | babaabababbbbaa=a >
babaabababbbbaa -> a

# < a,b | babaababbaaaaaa=a >
babaababbaaaaaa -> a

# < a,b | babaababbaaaaba=a >
babaababbaaaaba -> a
babaababbaaaaa -> abaababbaaaaba

# < a,b | babaababbaaabaa=a >
babaababbaaabaa -> a

# < a,b | babaababbaaabba=a >
babaababbaaabba -> a
babaababbaaaba -> abaababbaaabba
babaababbaaaa -> abaababbaaaba

# < a,b | babaababbaabaaa=a >
babaababbaabaaa -> a

# < a,b | babaababbaababa=a >
babaababbaababa -> a
babaababbaabaa -> abaababbaababa
babaababbaaa -> aababbaababa

# < a,b | babaababbaabbaa=a >
babaababbaabbaa -> a

# < a,b | babaababbaabbba=a >
babaababbaabbba -> a
babaababbaabba -> abaababbaabbba
babaababbaaba -> abaababbaabba
babaababbaaa -> abaababbaaba

# < a,b | babaababbabaaaa=a >
babaababbabaaaa -> a

# < a,b | babaababbababaa=a >
babaababbababaa -> a
babaababbaa -> ababbababaa

# < a,b | babaababbabbaaa=a >
babaababbabbaaa -> a

# < a,b | babaababbabbaba=a >
babaababbabbaba -> a
babaababbabbaa -> abaababbabbaba
babaababbaba -> aababbabbaba
babaababbaa -> aababbabbaa
babaababa -> aababbaba
babaabaa -> aababbaa
babaaa -> aababa

# < a,b | babaababbabbbaa=a >
babaababbabbbaa -> a

# < a,b | babaababbbaaaaa=a >
babaababbbaaaaa -> a

# < a,b | babaababbbaaaba=a >
babaababbbaaaba -> a
babaababbbaaaa -> abaababbbaaaba

# < a,b | babaababbbaabaa=a >
babaababbbaabaa -> a

# < a,b | babaababbbaabba=a >
babaababbbaabba -> a
babaababbbaaba -> abaababbbaabba
babaababbbaaa -> abaababbbaaba

# < a,b | babaababbbabaaa=a >
babaababbbabaaa -> a

# < a,b | babaababbbabbaa=a >
babaababbbabbaa -> a

# < a,b | babaababbbbaaaa=a >
babaababbbbaaaa -> a

# < a,b | babaababbbbaaba=a >
babaababbbbaaba -> a
babaababbbbaaa -> abaababbbbaaba

# < a,b | babaababbbbbaaa=a >
babaababbbbbaaa -> a

# < a,b | babaababbbbbbaa=a >
babaababbbbbbaa -> a

# < a,b | babaabbaaaaaaaa=a >
babaabbaaaaaaaa -> a

# < a,b | babaabbaaaaaaba=a >
babaabbaaaaaaba -> a
babaabbaaaaaaa -> abaabbaaaaaaba

# < a,b | babaabbaaaaabaa=a >
babaabbaaaaabaa -> a

# < a,b | babaabbaaaaabba=a >
babaabbaaaaabba -> a
babaabbaaaaaba -> abaabbaaaaabba
babaabbaaaaaa -> abaabbaaaaaba

# < a,b | babaabbaaaabaaa=a >
babaabbaaaabaaa -> a

# < a,b | babaabbaaaababa=a >
babaabbaaaababa -> a
babaabbaaaabaa -> abaabbaaaababa
babaabbaaaaa -> aabbaaaababa

# < a,b | babaabbaaaabbaa=a >
babaabbaaaabbaa -> a

# < a,b | babaabbaaaabbba=a >
babaabbaaaabbba -> a
babaabbaaaabba -> abaabbaaaabbba
babaabbaaaaba -> abaabbaaaabba
babaabbaaaaa -> abaabbaaaaba

# < a,b | babaabbaaabaaaa=a >
babaabbaaabaaaa -> a

# < a,b | babaabbaaabaaba=a >
babaabbaaabaaba -> a
babaabbaaabaaa -> abaabbaaabaaba

# < a,b | babaabbaaababaa=a >
babaabbaaababaa -> a
babaabbaaaa -> abbaaababaa

# < a,b | babaabbaaabbaaa=a >
babaabbaaabbaaa -> a

# < a,b | babaabbaaabbaba=a >
babaabbaaabbaba -> a
babaabbaaabbaa -> abaabbaaabbaba
babaabbaaaba -> aabbaaabbaba
babaabbaaaa -> aabbaaabbaa

# < a,b | babaabbaaabbbaa=a >
babaabbaaabbbaa -> a

# < a,b | babaabbaaabbbba=a >
babaabbaaabbbba -> a
babaabbaaabbba -> abaabbaaabbbba
babaabbaaabba -> abaabbaaabbba
babaabbaaaba -> abaabbaaabba
babaabbaaaa -> abaabbaaaba

# < a,b | babaabbaabaaaaa=a >
babaabbaabaaaaa -> a

# < a,b | babaabbaabaaaba=a >
babaabbaabaaaba -> a
babaabbaabaaaa -> abaabbaabaaaba

# < a,b | babaabbaabaabaa=a >
babaabbaabaabaa -> a

# < a,b | babaabbaabaabba=a >
babaabbaabaabba -> a
babaabbaabaaba -> abaabbaabaabba
babaabbaabaaa -> abaabbaabaaba

# < a,b | babaabbaababaaa=a >
babaabbaababaaa -> a

# < a,b | babaabbaababbaa=a >
babaabbaababbaa -> a

# < a,b | babaabbaabbaaaa=a >
babaabbaabbaaaa -> a

# < a,b | babaabbaabbaaba=a >
babaabbaabbaaba -> a
babaabbaabbaaa -> abaabbaabbaaba

# < a,b | babaabbaabbbaaa=a >
babaabbaabbbaaa -> a

# < a,b | babaabbaabbbbaa=a >
babaabbaabbbbaa -> a

# < a,b | babaabbaabbbbba=a >
babaabbaabbbbba -> a
babaabbaabbbba -> abaabbaabbbbba
babaabbaabbba -> abaabbaabbbba
babaabbaabba -> abaabbaabbba
babaabbaaba -> abaabbaabba
babaabbaaa -> abaabbaaba

# < a,b | babaabbabaaaaaa=a >
babaabbabaaaaaa -> a

# < a,b | babaabbabaaaaba=a >
babaabbabaaaaba -> a
babaabbabaaaaa -> abaabbabaaaaba

# < a,b | babaabbabaaabaa=a >
babaabbabaaabaa -> a

# < a,b | babaabbabaaabba=a >
babaabbabaaabba -> a
babaabbabaaaba -> abaabbabaaabba
babaabbabaaaa -> abaabbabaaaba

# < a,b | babaabbabaabaaa=a >
babaabbabaabaaa -> a

# < a,b | babaabbabaababa=a >
babaabbabaababa -> a
babaabbabaabaa -> abaabbabaababa
babaabbabaaa -> aabbabaababa

# < a,b | babaabbabaabbaa=a >
babaabbabaabbaa -> a

# < a,b | babaabbababaaaa=a >
babaabbababaaaa -> a

# < a,b | babaabbababaaba=a >
babaabbababaaba -> a
babaabbababaaa -> abaabbababaaba

# < a,b | babaabbababbaaa=a >
babaabbababbaaa -> a

# < a,b | babaabbababbbaa=a >
babaabbababbbaa -> a

# < a,b | babaabbabbaaaaa=a >
babaabbabbaaaaa -> a

# < a,b | babaabbabbaaaba=a >
babaabbabbaaaba -> a
babaabbabbaaaa -> abaabbabbaaaba

# < a,b | babaabbabbaabaa=a >
babaabbabbaabaa -> a

# < a,b | babaabbabbaabba=a >
babaabbabbaabba -> a
babaabbabbaaba -> abaabbabbaabba
babaabbabbaaa -> abaabbabbaaba

# < a,b | babaabbabbabaaa=a >
babaabbabbabaaa -> a

# < a,b | babaabbabbabbaa=a >
babaabbabbabbaa -> a

# < a,b | babaabbabbbaaaa=a >
babaabbabbbaaaa -> a

# < a,b | babaabbabbbaaba=a >
babaabbabbbaaba -> a
babaabbabbbaaa -> abaabbabbbaaba

# < a,b | babaabbabbbbaaa=a >
babaabbabbbbaaa -> a

# < a,b | babaabbabbbbbaa=a >
babaabbabbbbbaa -> a

# < a,b | babaabbbaaaaaaa=a >
babaabbbaaaaaaa -> a

# < a,b | babaabbbaaaaaba=a >
babaabbbaaaaaba -> a
babaabbbaaaaaa -> abaabbbaaaaaba

# < a,b | babaabbbaaaabaa=a >
babaabbbaaaabaa -> a

# < a,b | babaabbbaaaabba=a >
babaabbbaaaabba -> a
babaabbbaaaaba -> abaabbbaaaabba
babaabbbaaaaa -> abaabbbaaaaba

# < a,b | babaabbbaaabaaa=a >
babaabbbaaabaaa -> a

# < a,b | babaabbbaaababa=a >
babaabbbaaababa -> a
babaabbbaaabaa -> abaabbbaaababa
babaabbbaaaa -> aabbbaaababa

# < a,b | babaabbbaaabbaa=a >
babaabbbaaabbaa -> a

# < a,b | babaabbbaaabbba=a >
babaabbbaaabbba -> a
babaabbbaaabba -> abaabbbaaabbba
babaabbbaaaba -> abaabbbaaabba
babaabbbaaaa -> abaabbbaaaba

# < a,b | babaabbbaabaaaa=a >
babaabbbaabaaaa -> a

# < a,b | babaabbbaabaaba=a >
babaabbbaabaaba -> a
babaabbbaabaaa -> abaabbbaabaaba

# < a,b | babaabbbaababaa=a >
babaabbbaababaa -> a
babaabbbaaa -> abbbaababaa

# < a,b | babaabbbaabbaaa=a >
babaabbbaabbaaa -> a

# < a,b | babaabbbaabbaba=a >
babaabbbaabbaba -> a
babaabbbaabbaa -> abaabbbaabbaba
babaabbbaaba -> aabbbaabbaba
babaabbbaaa -> aabbbaabbaa

# < a,b | babaabbbaabbbaa=a >
babaabbbaabbbaa -> a

# < a,b | babaabbbaabbbba=a >
babaabbbaabbbba -> a
babaabbbaabbba -> abaabbbaabbbba
babaabbbaabba -> abaabbbaabbba
babaabbbaaba -> abaabbbaabba
babaabbbaaa -> abaabbbaaba

# < a,b | babaabbbabaaaaa=a >
babaabbbabaaaaa -> a

# < a,b | babaabbbabaaaba=a >
babaabbbabaaaba -> a
babaabbbabaaaa -> abaabbbabaaaba

# < a,b | babaabbbabaabaa=a >
babaabbbabaabaa -> a

# < a,b | babaabbbabaabba=a >
babaabbbabaabba -> a
babaabbbabaaba -> abaabbbabaabba
babaabbbabaaa -> abaabbbabaaba

# < a,b | babaabbbababaaa=a >
babaabbbababaaa -> a

# < a,b | babaabbbababbaa=a >
babaabbbababbaa -> a

# < a,b | babaabbbabbaaaa=a >
babaabbbabbaaaa -> a

# < a,b | babaabbbabbaaba=a >
babaabbbabbaaba -> a
babaabbbabbaaa -> abaabbbabbaaba

# < a,b | babaabbbabbbaaa=a >
babaabbbabbbaaa -> a

# < a,b | babaabbbabbbbaa=a >
babaabbbabbbbaa -> a

# < a,b | babaabbbbaaaaaa=a >
babaabbbbaaaaaa -> a

# < a,b | babaabbbbaaaaba=a >
babaabbbbaaaaba -> a
babaabbbbaaaaa -> abaabbbbaaaaba

# < a,b | babaabbbbaaabaa=a >
babaabbbbaaabaa -> a

# < a,b | babaabbbbaaabba=a >
babaabbbbaaabba -> a
babaabbbbaaaba -> abaabbbbaaabba
babaabbbbaaaa -> abaabbbbaaaba

# < a,b | babaabbbbaabaaa=a >
babaabbbbaabaaa -> a

# < a,b | babaabbbbaababa=a >
babaabbbbaababa -> a
babaabbbbaabaa -> abaabbbbaababa
babaabbbbaaa -> aabbbbaababa

# < a,b | babaabbbbaabbaa=a >
babaabbbbaabbaa -> a

# < a,b | babaabbbbaabbba=a >
babaabbbbaabbba -> a
babaabbbbaabba -> abaabbbbaabbba
babaabbbbaaba -> abaabbbbaabba
babaabbbbaaa -> abaabbbbaaba

# < a,b | babaabbbbabaaaa=a >
babaabbbbabaaaa -> a

# < a,b | babaabbbbabaaba=a >
babaabbbbabaaba -> a
babaabbbbabaaa -> abaabbbbabaaba

# < a,b | babaabbbbababaa=a >
babaabbbbababaa -> a
babaabbbbaa -> abbbbababaa

# < a,b | babaabbbbabbaaa=a >
babaabbbbabbaaa -> a

# < a,b | babaabbbbabbbaa=a >
babaabbbbabbbaa -> a

# < a,b | babaabbbbbaaaaa=a >
babaabbbbbaaaaa -> a

# < a,b | babaabbbbbaaaba=a >
babaabbbbbaaaba -> a
babaabbbbbaaaa -> abaabbbbbaaaba

# < a,b | babaabbbbbaabaa=a >
babaabbbbbaabaa -> a

# < a,b | babaabbbbbaabba=a >
babaabbbbbaabba -> a
babaabbbbbaaba -> abaabbbbbaabba
babaabbbbbaaa -> abaabbbbbaaba

# < a,b | babaabbbbbabaaa=a >
babaabbbbbabaaa -> a

# < a,b | babaabbbbbabbaa=a >
babaabbbbbabbaa -> a

# < a,b | babaabbbbbbaaaa=a >
babaabbbbbbaaaa -> a

# < a,b | babaabbbbbbaaba=a >
babaabbbbbbaaba -> a
babaabbbbbbaaa -> abaabbbbbbaaba

# < a,b | babaabbbbbbbaaa=a >
babaabbbbbbbaaa -> a

# < a,b | babaabbbbbbbbaa=a >
babaabbbbbbbbaa -> a

# < a,b | babaabbbbbbbbba=a >
babaabbbbbbbbba -> a
babaabbbbbbbba -> abaabbbbbbbbba
babaabbbbbbba -> abaabbbbbbbba
babaabbbbbba -> abaabbbbbbba
babaabbbbba -> abaabbbbbba
babaabbbba -> abaabbbbba
babaabbba -> abaabbbba
babaabba -> abaabbba
babaaba -> abaabba
babaaa -> abaaba

# < a,b | bababaaaaaaaaaa=a >
bababaaaaaaaaaa -> a

# < a,b | bababaaaaaaaaba=a >
bababaaaaaaaaba -> a
bababaaaaaaaaa -> ababaaaaaaaaba

# < a,b | bababaaaaaaabaa=a >
bababaaaaaaabaa -> a

# < a,b | bababaaaaaaabba=a >
bababaaaaaaabba -> a
bababaaaaaaaba -> ababaaaaaaabba
bababaaaaaaaa -> ababaaaaaaaba

# < a,b | bababaaaaaabaaa=a >
bababaaaaaabaaa -> a

# < a,b | bababaaaaaababa=a >
bababaaaaaababa -> a
bababaaaaaabaa -> ababaaaaaababa
bababaaaaaaa -> abaaaaaababa

# < a,b | bababaaaaaabbaa=a >
bababaaaaaabbaa -> a

# < a,b | bababaaaaaabbba=a >
bababaaaaaabbba -> a
bababaaaaaabba -> ababaaaaaabbba
bababaaaaaaba -> ababaaaaaabba
bababaaaaaaa -> ababaaaaaaba

# < a,b | bababaaaaabaaaa=a >
bababaaaaabaaaa -> a

# < a,b | bababaaaaabaaba=a >
bababaaaaabaaba -> a
bababaaaaabaaa -> ababaaaaabaaba

# < a,b | bababaaaaababaa=a >
bababaaaaababaa -> a

# < a,b | bababaaaaabbaaa=a >
bababaaaaabbaaa -> a

# < a,b | bababaaaaabbaba=a >
bababaaaaabbaba -> a
bababaaaaabbaa -> ababaaaaabbaba
bababaaaaaba -> abaaaaabbaba
bababaaaaaa -> abaaaaabbaa

# < a,b | bababaaaaabbbaa=a >
bababaaaaabbbaa -> a

# < a,b | bababaaaaabbbba=a >
bababaaaaabbbba -> a
bababaaaaabbba -> ababaaaaabbbba
bababaaaaabba -> ababaaaaabbba
bababaaaaaba -> ababaaaaabba
bababaaaaaa -> ababaaaaaba

# < a,b | bababaaaabaaaaa=a >
bababaaaabaaaaa -> a

# < a,b | bababaaaabaaaba=a >
bababaaaabaaaba -> a
bababaaaabaaaa -> ababaaaabaaaba

# < a,b | bababaaaabaabaa=a >
bababaaaabaabaa -> a

# < a,b | bababaaaabaabba=a >
bababaaaabaabba -> a
bababaaaabaaba -> ababaaaabaabba
bababaaaabaaa -> ababaaaabaaba

# < a,b | bababaaaababaaa=a >
bababaaaababaaa -> a

# < a,b | bababaaaabababa=a >
bababaaaabababa -> a
bababaaaababaa -> ababaaaabababa
bababaaaabaa -> abaaaabababa
bababaaaaa -> aaaabababa

# < a,b | bababaaaababbaa=a >
bababaaaababbaa -> a

# < a,b | bababaaaabbaaaa=a >
bababaaaabbaaaa -> a

# < a,b | bababaaaabbaaba=a >
bababaaaabbaaba -> a
bababaaaabbaaa -> ababaaaabbaaba

# < a,b | bababaaaabbabaa=a >
bababaaaabbabaa -> a

# < a,b | bababaaaabbbaaa=a >
bababaaaabbbaaa -> a

# < a,b | bababaaaabbbbaa=a >
bababaaaabbbbaa -> a

# < a,b | bababaaaabbbbba=a >
bababaaaabbbbba -> a
bababaaaabbbba -> ababaaaabbbbba
bababaaaabbba -> ababaaaabbbba
bababaaaabba -> ababaaaabbba
bababaaaaba -> ababaaaabba
bababaaaaa -> ababaaaaba

# < a,b | bababaaabaaaaaa=a >
bababaaabaaaaaa -> a

# < a,b | bababaaabaaaaba=a >
bababaaabaaaaba -> a
bababaaabaaaaa -> ababaaabaaaaba

# < a,b | bababaaabaaabaa=a >
bababaaabaaabaa -> a

# < a,b | bababaaabaaabba=a >
bababaaabaaabba -> a
bababaaabaaaba -> ababaaabaaabba
bababaaabaaaa -> ababaaabaaaba

# < a,b | bababaaabaabaaa=a >
bababaaabaabaaa -> a

# < a,b | bababaaabaababa=a >
bababaaabaababa -> a
bababaaabaabaa -> ababaaabaababa
bababaaabaaa -> abaaabaababa

# < a,b | bababaaabaabbaa=a >
bababaaabaabbaa -> a

# < a,b | bababaaabaabbba=a >
bababaaabaabbba -> a
bababaaabaabba -> ababaaabaabbba
bababaaabaaba -> ababaaabaabba
bababaaabaaa -> ababaaabaaba

# < a,b | bababaaababaaaa=a >
bababaaababaaaa -> a

# < a,b | bababaaababaaba=a >
bababaaababaaba -> a
bababaaababaaa -> ababaaababaaba

# < a,b | bababaaabababaa=a >
bababaaabababaa -> a
bababaaaa -> aabababaa

# < a,b | bababaaababbaaa=a >
bababaaababbaaa -> a

# < a,b | bababaaababbaba=a >
bababaaababbaba -> a
bababaaababbaa -> ababaaababbaba
bababaaababa -> abaaababbaba
bababaaabaa -> abaaababbaa
bababaaaa -> abaaababa

# < a,b | bababaaababbbaa=a >
bababaaababbbaa -> a

# < a,b | bababaaabbaaaaa=a >
bababaaabbaaaaa -> a

# < a,b | bababaaabbaaaba=a >
bababaaabbaaaba -> a
bababaaabbaaaa -> ababaaabbaaaba

# < a,b | bababaaabbaabaa=a >
bababaaabbaabaa -> a

# < a,b | bababaaabbaabba=a >
bababaaabbaabba -> a
bababaaabbaaba -> ababaaabbaabba
bababaaabbaaa -> ababaaabbaaba

# < a,b | bababaaabbabaaa=a >
bababaaabbabaaa -> a

# < a,b | bababaaabbababa=a >
bababaaabbababa -> a
bababaaabbabaa -> ababaaabbababa
bababaaabbaa -> abaaabbababa
bababaaaba -> aaabbababa
bababaaaa -> aaabbabaa

# < a,b | bababaaabbabbaa=a >
bababaaabbabbaa -> a

# < a,b | bababaaabbbaaaa=a >
bababaaabbbaaaa -> a

# < a,b | bababaaabbbaaba=a >
bababaaabbbaaba -> a
bababaaabbbaaa -> ababaaabbbaaba

# < a,b | bababaaabbbabaa=a >
bababaaabbbabaa -> a

# < a,b | bababaaabbbbaaa=a >
bababaaabbbbaaa -> a

# < a,b | bababaaabbbbbaa=a >
bababaaabbbbbaa -> a

# < a,b | bababaaabbbbbba=a >
bababaaabbbbbba -> a
bababaaabbbbba -> ababaaabbbbbba
bababaaabbbba -> ababaaabbbbba
bababaaabbba -> ababaaabbbba
bababaaabba -> ababaaabbba
bababaaaba -> ababaaabba
bababaaaa -> ababaaaba

# < a,b | bababaabaaaaaaa=a >
bababaabaaaaaaa -> a

# < a,b | bababaabaaaaaba=a >
bababaabaaaaaba -> a
bababaabaaaaaa -> ababaabaaaaaba

# < a,b | bababaabaaaabaa=a >
bababaabaaaabaa -> a

# < a,b | bababaabaaaabba=a >
bababaabaaaabba -> a
bababaabaaaaba -> ababaabaaaabba
bababaabaaaaa -> ababaabaaaaba

# < a,b | bababaabaaabaaa=a >
bababaabaaabaaa -> a

# < a,b | bababaabaaababa=a >
bababaabaaababa -> a
bababaabaaabaa -> ababaabaaababa
bababaabaaaa -> abaabaaababa

# < a,b | bababaabaaabbaa=a >
bababaabaaabbaa -> a

# < a,b | bababaabaaabbba=a >
bababaabaaabbba -> a
bababaabaaabba -> ababaabaaabbba
bababaabaaaba -> ababaabaaabba
bababaabaaaa -> ababaabaaaba

# < a,b | bababaabaabaaaa=a >
bababaabaabaaaa -> a

# < a,b | bababaabaabaaba=a >
bababaabaabaaba -> a
bababaabaabaaa -> ababaabaabaaba

# < a,b | bababaabaababaa=a >
bababaabaababaa -> a

# < a,b | bababaabaabbaaa=a >
bababaabaabbaaa -> a

# < a,b | bababaabaabbaba=a >
bababaabaabbaba -> a
bababaabaabbaa -> ababaabaabbaba
bababaabaaba -> abaabaabbaba
bababaabaaa -> abaabaabbaa

# < a,b | bababaabaabbbaa=a >
bababaabaabbbaa -> a

# < a,b | bababaabaabbbba=a >
bababaabaabbbba -> a
bababaabaabbba -> ababaabaabbbba
bababaabaabba -> ababaabaabbba
bababaabaaba -> ababaabaabba
bababaabaaa -> ababaabaaba

# < a,b | bababaababaaaaa=a >
bababaababaaaaa -> a

# < a,b | bababaababaaaba=a >
bababaababaaaba -> a
bababaababaaaa -> ababaababaaaba

# < a,b | bababaababaabaa=a >
bababaababaabaa -> a

# < a,b | bababaababaabba=a >
bababaababaabba -> a
bababaababaaba -> ababaababaabba
bababaababaaa -> ababaababaaba

# < a,b | bababaabababaaa=a >
bababaabababaaa -> a

# < a,b | bababaabababbaa=a >
bababaabababbaa -> a

# < a,b | bababaababbaaaa=a >
bababaababbaaaa -> a

# < a,b | bababaababbaaba=a >
bababaababbaaba -> a
bababaababbaaa -> ababaababbaaba

# < a,b | bababaababbabaa=a >
bababaababbabaa -> a

# < a,b | bababaababbbaaa=a >
bababaababbbaaa -> a

# < a,b | bababaababbbbaa=a >
bababaababbbbaa -> a

# < a,b | bababaabbaaaaaa=a >
bababaabbaaaaaa -> a

# < a,b | bababaabbaaaaba=a >
bababaabbaaaaba -> a
bababaabbaaaaa -> ababaabbaaaaba

# < a,b | bababaabbaaabaa=a >
bababaabbaaabaa -> a

# < a,b | bababaabbaaabba=a >
bababaabbaaabba -> a
bababaabbaaaba -> ababaabbaaabba
bababaabbaaaa -> ababaabbaaaba

# < a,b | bababaabbaabaaa=a >
bababaabbaabaaa -> a

# < a,b | bababaabbaababa=a >
bababaabbaababa -> a
bababaabbaabaa -> ababaabbaababa
bababaabbaaa -> abaabbaababa

# < a,b | bababaabbaabbaa=a >
bababaabbaabbaa -> a

# < a,b | bababaabbaabbba=a >
bababaabbaabbba -> a
bababaabbaabba -> ababaabbaabbba
bababaabbaaba -> ababaabbaabba
bababaabbaaa -> ababaabbaaba

# < a,b | bababaabbabaaaa=a >
bababaabbabaaaa -> a

# < a,b | bababaabbabaaba=a >
bababaabbabaaba -> a
bababaabbabaaa -> ababaabbabaaba

# < a,b | bababaabbabbaaa=a >
bababaabbabbaaa -> a

# < a,b | bababaabbabbaba=a >
bababaabbabbaba -> a
bababaabbabbaa -> ababaabbabbaba
bababaabbaba -> abaabbabbaba
bababaabbaa -> abaabbabbaa
bababaaba -> abaabbaba
bababaaa -> abaabbaa

# < a,b | bababaabbabbbaa=a >
bababaabbabbbaa -> a

# < a,b | bababaabbbaaaaa=a >
bababaabbbaaaaa -> a

# < a,b | bababaabbbaaaba=a >
bababaabbbaaaba -> a
bababaabbbaaaa -> ababaabbbaaaba

# < a,b | bababaabbbaabaa=a >
bababaabbbaabaa -> a

# < a,b | bababaabbbaabba=a >
bababaabbbaabba -> a
bababaabbbaaba -> ababaabbbaabba
bababaabbbaaa -> ababaabbbaaba

# < a,b | bababaabbbabaaa=a >
bababaabbbabaaa -> a

# < a,b | bababaabbbabbaa=a >
bababaabbbabbaa -> a

# < a,b | bababaabbbbaaaa=a >
bababaabbbbaaaa -> a

# < a,b | bababaabbbbaaba=a >
bababaabbbbaaba -> a
bababaabbbbaaa -> ababaabbbbaaba

# < a,b | bababaabbbbabaa=a >
bababaabbbbabaa -> a

# < a,b | bababaabbbbbaaa=a >
bababaabbbbbaaa -> a

# < a,b | bababaabbbbbbaa=a >
bababaabbbbbbaa -> a

# < a,b | bababaabbbbbbba=a >
bababaabbbbbbba -> a
bababaabbbbbba -> ababaabbbbbbba
bababaabbbbba -> ababaabbbbbba
bababaabbbba -> ababaabbbbba
bababaabbba -> ababaabbbba
bababaabba -> ababaabbba
bababaaba -> ababaabba
bababaaa -> ababaaba

# < a,b | babababaaaaaaaa=a >
babababaaaaaaaa -> a

# < a,b | babababaaaaaaba=a >
babababaaaaaaba -> a
babababaaaaaaa -> abababaaaaaaba

# < a,b | babababaaaaabaa=a >
babababaaaaabaa -> a

# < a,b | babababaaaaabba=a >
babababaaaaabba -> a
babababaaaaaba -> abababaaaaabba
babababaaaaaa -> abababaaaaaba

# < a,b | babababaaaabaaa=a >
babababaaaabaaa -> a

# < a,b | babababaaaababa=a >
babababaaaababa -> a
babababaaaabaa -> abababaaaababa
babababaaaaa -> ababaaaababa

# < a,b | babababaaaabbaa=a >
babababaaaabbaa -> a

# < a,b | babababaaaabbba=a >
babababaaaabbba -> a
babababaaaabba -> abababaaaabbba
babababaaaaba -> abababaaaabba
babababaaaaa -> abababaaaaba

# < a,b | babababaaabaaaa=a >
babababaaabaaaa -> a

# < a,b | babababaaabaaba=a >
babababaaabaaba -> a
babababaaabaaa -> abababaaabaaba

# < a,b | babababaaababaa=a >
babababaaababaa -> a

# < a,b | babababaaabbaaa=a >
babababaaabbaaa -> a

# < a,b | babababaaabbaba=a >
babababaaabbaba -> a
babababaaabbaa -> abababaaabbaba
babababaaaba -> ababaaabbaba
babababaaaa -> ababaaabbaa

# < a,b | babababaaabbbaa=a >
babababaaabbbaa -> a

# < a,b | babababaaabbbba=a >
babababaaabbbba -> a
babababaaabbba -> abababaaabbbba
babababaaabba -> abababaaabbba
babababaaaba -> abababaaabba
babababaaaa -> abababaaaba

# < a,b | babababaabaaaaa=a >
babababaabaaaaa -> a

# < a,b | babababaabaaaba=a >
babababaabaaaba -> a
babababaabaaaa -> abababaabaaaba

# < a,b | babababaabaabaa=a >
babababaabaabaa -> a

# < a,b | babababaabaabba=a >
babababaabaabba -> a
babababaabaaba -> abababaabaabba
babababaabaaa -> abababaabaaba

# < a,b | babababaababaaa=a >
babababaababaaa -> a

# < a,b | babababaabababa=a >
babababaabababa -> a
babababaababaa -> abababaabababa
babababaabaa -> ababaabababa
babababaaa -> abaabababa

# < a,b | babababaababbaa=a >
babababaababbaa -> a

# < a,b | babababaabbaaaa=a >
babababaabbaaaa -> a

# < a,b | babababaabbaaba=a >
babababaabbaaba -> a
babababaabbaaa -> abababaabbaaba

# < a,b | babababaabbabaa=a >
babababaabbabaa -> a

# < a,b | babababaabbbaaa=a >
babababaabbbaaa -> a

# < a,b | babababaabbbbaa=a >
babababaabbbbaa -> a

# < a,b | babababaabbbbba=a >
babababaabbbbba -> a
babababaabbbba -> abababaabbbbba
babababaabbba -> abababaabbbba
babababaabba -> abababaabbba
babababaaba -> abababaabba
babababaaa -> abababaaba

# < a,b | bababababaaaaaa=a >
bababababaaaaaa -> a

# < a,b | bababababaaaaba=a >
bababababaaaaba -> a
bababababaaaaa -> ababababaaaaba

# < a,b | bababababaaabaa=a >
bababababaaabaa -> a

# < a,b | bababababaaabba=a >
bababababaaabba -> a
bababababaaaba -> ababababaaabba
bababababaaaa -> ababababaaaba

# < a,b | bababababaabaaa=a >
bababababaabaaa -> a

# < a,b | bababababaababa=a >
bababababaababa -> a
bababababaabaa -> ababababaababa
bababababaaa -> abababaababa

# < a,b | bababababaabbaa=a >
bababababaabbaa -> a

# < a,b | bababababaabbba=a >
bababababaabbba -> a
bababababaabba -> ababababaabbba
bababababaaba -> ababababaabba
bababababaaa -> ababababaaba

# < a,b | babababababaaaa=a >
babababababaaaa -> a

# < a,b | babababababaaba=a >
babababababaaba -> a
babababababaaa -> abababababaaba

# < a,b | bababababababaa=a >
bababababababaa -> a

# < a,b | babababababbaaa=a >
babababababbaaa -> a

# < a,b | babababababbbaa=a >
babababababbbaa -> a

# < a,b | bababababbaaaaa=a >
bababababbaaaaa -> a

# < a,b | bababababbaaaba=a >
bababababbaaaba -> a
bababababbaaaa -> ababababbaaaba

# < a,b | bababababbaabaa=a >
bababababbaabaa -> a

# < a,b | bababababbaabba=a >
bababababbaabba -> a
bababababbaaba -> ababababbaabba
bababababbaaa -> ababababbaaba

# < a,b | bababababbabaaa=a >
bababababbabaaa -> a

# < a,b | bababababbabbaa=a >
bababababbabbaa -> a

# < a,b | bababababbbaaaa=a >
bababababbbaaaa -> a

# < a,b | bababababbbaaba=a >
bababababbbaaba -> a
bababababbbaaa -> ababababbbaaba

# < a,b | bababababbbabaa=a >
bababababbbabaa -> a

# < a,b | bababababbbbaaa=a >
bababababbbbaaa -> a

# < a,b | bababababbbbbaa=a >
bababababbbbbaa -> a

# < a,b | babababbaaaaaaa=a >
babababbaaaaaaa -> a

# < a,b | babababbaaaaaba=a >
babababbaaaaaba -> a
babababbaaaaaa -> abababbaaaaaba

# < a,b | babababbaaaabaa=a >
babababbaaaabaa -> a

# < a,b | babababbaaaabba=a >
babababbaaaabba -> a
babababbaaaaba -> abababbaaaabba
babababbaaaaa -> abababbaaaaba

# < a,b | babababbaaabaaa=a >
babababbaaabaaa -> a

# < a,b | babababbaaababa=a >
babababbaaababa -> a
babababbaaabaa -> abababbaaababa
babababbaaaa -> ababbaaababa

# < a,b | babababbaaabbaa=a >
babababbaaabbaa -> a

# < a,b | babababbaaabbba=a >
babababbaaabbba -> a
babababbaaabba -> abababbaaabbba
babababbaaaba -> abababbaaabba
babababbaaaa -> abababbaaaba

# < a,b | babababbaabaaaa=a >
babababbaabaaaa -> a

# < a,b | babababbaabaaba=a >
babababbaabaaba -> a
babababbaabaaa -> abababbaabaaba

# < a,b | babababbaababaa=a >
babababbaababaa -> a

# < a,b | babababbaabbaaa=a >
babababbaabbaaa -> a

# < a,b | babababbaabbaba=a >
babababbaabbaba -> a
babababbaabbaa -> abababbaabbaba
babababbaaba -> ababbaabbaba
babababbaaa -> ababbaabbaa

# < a,b | babababbaabbbaa=a >
babababbaabbbaa -> a

# < a,b | babababbaabbbba=a >
babababbaabbbba -> a
babababbaabbba -> abababbaabbbba
babababbaabba -> abababbaabbba
babababbaaba -> abababbaabba
babababbaaa -> abababbaaba

# < a,b | babababbabaaaaa=a >
babababbabaaaaa -> a

# < a,b | babababbabaaaba=a >
babababbabaaaba -> a
babababbabaaaa -> abababbabaaaba

# < a,b | babababbabaabaa=a >
babababbabaabaa -> a

# < a,b | babababbabaabba=a >
babababbabaabba -> a
babababbabaaba -> abababbabaabba
babababbabaaa -> abababbabaaba

# < a,b | babababbababaaa=a >
babababbababaaa -> a

# < a,b | babababbabababa=a >
babababbabababa -> a
babababbababaa -> abababbabababa
babababbabaa -> ababbabababa
babababbaa -> abbabababa

# < a,b | babababbababbaa=a >
babababbababbaa -> a

# < a,b | babababbabbaaaa=a >
babababbabbaaaa -> a

# < a,b | babababbabbaaba=a >
babababbabbaaba -> a
babababbabbaaa -> abababbabbaaba

# < a,b | babababbabbabaa=a >
babababbabbabaa -> a

# < a,b | babababbabbbaaa=a >
babababbabbbaaa -> a

# < a,b | babababbabbbbaa=a >
babababbabbbbaa -> a

# < a,b | babababbbaaaaaa=a >
babababbbaaaaaa -> a

# < a,b | babababbbaaaaba=a >
babababbbaaaaba -> a
babababbbaaaaa -> abababbbaaaaba

# < a,b | babababbbaaabaa=a >
babababbbaaabaa -> a

# < a,b | babababbbaaabba=a >
babababbbaaabba -> a
babababbbaaaba -> abababbbaaabba
babababbbaaaa -> abababbbaaaba

# < a,b | babababbbaabaaa=a >
babababbbaabaaa -> a

# < a,b | babababbbaababa=a >
babababbbaababa -> a
babababbbaabaa -> abababbbaababa
babababbbaaa -> ababbbaababa

# < a,b | babababbbaabbaa=a >
babababbbaabbaa -> a

# < a,b | babababbbaabbba=a >
babababbbaabbba -> a
babababbbaabba -> abababbbaabbba
babababbbaaba -> abababbbaabba
babababbbaaa -> abababbbaaba

# < a,b | babababbbabaaaa=a >
babababbbabaaaa -> a

# < a,b | babababbbabaaba=a >
babababbbabaaba -> a
babababbbabaaa -> abababbbabaaba

# < a,b | babababbbababaa=a >
babababbbababaa -> a

# < a,b | babababbbabbaaa=a >
babababbbabbaaa -> a

# < a,b | babababbbabbbaa=a >
babababbbabbbaa -> a

# < a,b | babababbbbaaaaa=a >
babababbbbaaaaa -> a

# < a,b | babababbbbaaaba=a >
babababbbbaaaba -> a
babababbbbaaaa -> abababbbbaaaba

# < a,b | babababbbbaabaa=a >
babababbbbaabaa -> a

# < a,b | babababbbbaabba=a >
babababbbbaabba -> a
babababbbbaaba -> abababbbbaabba
babababbbbaaa -> abababbbbaaba

# < a,b | babababbbbabaaa=a >
babababbbbabaaa -> a

# < a,b | babababbbbabbaa=a >
babababbbbabbaa -> a

# < a,b | babababbbbbaaaa=a >
babababbbbbaaaa -> a

# < a,b | babababbbbbaaba=a >
babababbbbbaaba -> a
babababbbbbaaa -> abababbbbbaaba

# < a,b | babababbbbbabaa=a >
babababbbbbabaa -> a

# < a,b | babababbbbbbaaa=a >
babababbbbbbaaa -> a

# < a,b | babababbbbbbbaa=a >
babababbbbbbbaa -> a

# < a,b | bababbaaaaaaaaa=a >
bababbaaaaaaaaa -> a

# < a,b | bababbaaaaaaaba=a >
bababbaaaaaaaba -> a
bababbaaaaaaaa -> ababbaaaaaaaba

# < a,b | bababbaaaaaabaa=a >
bababbaaaaaabaa -> a

# < a,b | bababbaaaaaabba=a >
bababbaaaaaabba -> a
bababbaaaaaaba -> ababbaaaaaabba
bababbaaaaaaa -> ababbaaaaaaba

# < a,b | bababbaaaaabaaa=a >
bababbaaaaabaaa -> a

# < a,b | bababbaaaaababa=a >
bababbaaaaababa -> a
bababbaaaaabaa -> ababbaaaaababa
bababbaaaaaa -> abbaaaaababa

# < a,b | bababbaaaaabbaa=a >
bababbaaaaabbaa -> a

# < a,b | bababbaaaaabbba=a >
bababbaaaaabbba -> a
bababbaaaaabba -> ababbaaaaabbba
bababbaaaaaba -> ababbaaaaabba
bababbaaaaaa -> ababbaaaaaba

# < a,b | bababbaaaabaaaa=a >
bababbaaaabaaaa -> a

# < a,b | bababbaaaabaaba=a >
bababbaaaabaaba -> a
bababbaaaabaaa -> ababbaaaabaaba

# < a,b | bababbaaaababaa=a >
bababbaaaababaa -> a

# < a,b | bababbaaaabbaaa=a >
bababbaaaabbaaa -> a

# < a,b | bababbaaaabbaba=a >
bababbaaaabbaba -> a
bababbaaaabbaa -> ababbaaaabbaba
bababbaaaaba -> abbaaaabbaba
bababbaaaaa -> abbaaaabbaa

# < a,b | bababbaaaabbbaa=a >
bababbaaaabbbaa -> a

# < a,b | bababbaaaabbbba=a >
bababbaaaabbbba -> a
bababbaaaabbba -> ababbaaaabbbba
bababbaaaabba -> ababbaaaabbba
bababbaaaaba -> ababbaaaabba
bababbaaaaa -> ababbaaaaba

# < a,b | bababbaaabaaaaa=a >
bababbaaabaaaaa -> a

# < a,b | bababbaaabaaaba=a >
bababbaaabaaaba -> a
bababbaaabaaaa -> ababbaaabaaaba

# < a,b | bababbaaabaabaa=a >
bababbaaabaabaa -> a

# < a,b | bababbaaabaabba=a >
bababbaaabaabba -> a
bababbaaabaaba -> ababbaaabaabba
bababbaaabaaa -> ababbaaabaaba

# < a,b | bababbaaababaaa=a >
bababbaaababaaa -> a

# < a,b | bababbaaabababa=a >
bababbaaabababa -> a
bababbaaababaa -> ababbaaabababa
bababbaaabaa -> abbaaabababa

# < a,b | bababbaaababbaa=a >
bababbaaababbaa -> a

# < a,b | bababbaaabbaaaa=a >
bababbaaabbaaaa -> a

# < a,b | bababbaaabbaaba=a >
bababbaaabbaaba -> a
bababbaaabbaaa -> ababbaaabbaaba

# < a,b | bababbaaabbabaa=a >
bababbaaabbabaa -> a

# < a,b | bababbaaabbbaaa=a >
bababbaaabbbaaa -> a

# < a,b | bababbaaabbbbaa=a >
bababbaaabbbbaa -> a

# < a,b | bababbaaabbbbba=a >
bababbaaabbbbba -> a
bababbaaabbbba -> ababbaaabbbbba
bababbaaabbba -> ababbaaabbbba
bababbaaabba -> ababbaaabbba
bababbaaaba -> ababbaaabba
bababbaaaa -> ababbaaaba

# < a,b | bababbaabaaaaaa=a >
bababbaabaaaaaa -> a

# < a,b | bababbaabaaaaba=a >
bababbaabaaaaba -> a
bababbaabaaaaa -> ababbaabaaaaba

# < a,b | bababbaabaaabaa=a >
bababbaabaaabaa -> a

# < a,b | bababbaabaaabba=a >
bababbaabaaabba -> a
bababbaabaaaba -> ababbaabaaabba
bababbaabaaaa -> ababbaabaaaba

# < a,b | bababbaabaabaaa=a >
bababbaabaabaaa -> a

# < a,b | bababbaabaababa=a >
bababbaabaababa -> a
bababbaabaabaa -> ababbaabaababa
bababbaabaaa -> abbaabaababa

# < a,b | bababbaabaabbaa=a >
bababbaabaabbaa -> a

# < a,b | bababbaabaabbba=a >
bababbaabaabbba -> a
bababbaabaabba -> ababbaabaabbba
bababbaabaaba -> ababbaabaabba
bababbaabaaa -> ababbaabaaba

# < a,b | bababbaababaaaa=a >
bababbaababaaaa -> a

# < a,b | bababbaababaaba=a >
bababbaababaaba -> a
bababbaababaaa -> ababbaababaaba

# < a,b | bababbaabababaa=a >
bababbaabababaa -> a

# < a,b | bababbaababbaaa=a >
bababbaababbaaa -> a

# < a,b | bababbaababbaba=a >
bababbaababbaba -> a
bababbaababbaa -> ababbaababbaba
bababbaababa -> abbaababbaba
bababbaabaa -> abbaababbaa
bababbaaa -> abbaababa

# < a,b | bababbaababbbaa=a >
bababbaababbbaa -> a

# < a,b | bababbaabbaaaaa=a >
bababbaabbaaaaa -> a

# < a,b | bababbaabbaaaba=a >
bababbaabbaaaba -> a
bababbaabbaaaa -> ababbaabbaaaba

# < a,b | bababbaabbaabaa=a >
bababbaabbaabaa -> a

# < a,b | bababbaabbaabba=a >
bababbaabbaabba -> a
bababbaabbaaba -> ababbaabbaabba
bababbaabbaaa -> ababbaabbaaba

# < a,b | bababbaabbabaaa=a >
bababbaabbabaaa -> a

# < a,b | bababbaabbababa=a >
bababbaabbababa -> a
bababbaabbabaa -> ababbaabbababa
bababbaabbaa -> abbaabbababa

# < a,b | bababbaabbabbaa=a >
bababbaabbabbaa -> a

# < a,b | bababbaabbbaaaa=a >
bababbaabbbaaaa -> a

# < a,b | bababbaabbbaaba=a >
bababbaabbbaaba -> a
bababbaabbbaaa -> ababbaabbbaaba

# < a,b | bababbaabbbabaa=a >
bababbaabbbabaa -> a

# < a,b | bababbaabbbbaaa=a >
bababbaabbbbaaa -> a

# < a,b | bababbaabbbbbaa=a >
bababbaabbbbbaa -> a

# < a,b | bababbaabbbbbba=a >
bababbaabbbbbba -> a
bababbaabbbbba -> ababbaabbbbbba
bababbaabbbba -> ababbaabbbbba
bababbaabbba -> ababbaabbbba
bababbaabba -> ababbaabbba
bababbaaba -> ababbaabba
bababbaaa -> ababbaaba

# < a,b | bababbabaaaaaaa=a >
bababbabaaaaaaa -> a

# < a,b | bababbabaaaaaba=a >
bababbabaaaaaba -> a
bababbabaaaaaa -> ababbabaaaaaba

# < a,b | bababbabaaaabaa=a >
bababbabaaaabaa -> a

# < a,b | bababbabaaaabba=a >
bababbabaaaabba -> a
bababbabaaaaba -> ababbabaaaabba
bababbabaaaaa -> ababbabaaaaba

# < a,b | bababbabaaabaaa=a >
bababbabaaabaaa -> a

# < a,b | bababbabaaababa=a >
bababbabaaababa -> a
bababbabaaabaa -> ababbabaaababa
bababbabaaaa -> abbabaaababa

# < a,b | bababbabaaabbaa=a >
bababbabaaabbaa -> a

# < a,b | bababbabaaabbba=a >
bababbabaaabbba -> a
bababbabaaabba -> ababbabaaabbba
bababbabaaaba -> ababbabaaabba
bababbabaaaa -> ababbabaaaba

# < a,b | bababbabaabaaaa=a >
bababbabaabaaaa -> a

# < a,b | bababbabaabaaba=a >
bababbabaabaaba -> a
bababbabaabaaa -> ababbabaabaaba

# < a,b | bababbabaababaa=a >
bababbabaababaa -> a

# < a,b | bababbabaabbaaa=a >
bababbabaabbaaa -> a

# < a,b | bababbabaabbaba=a >
bababbabaabbaba -> a
bababbabaabbaa -> ababbabaabbaba
bababbabaaba -> abbabaabbaba
bababbabaaa -> abbabaabbaa

# < a,b | bababbabaabbbaa=a >
bababbabaabbbaa -> a

# < a,b | bababbabaabbbba=a >
bababbabaabbbba -> a
bababbabaabbba -> ababbabaabbbba
bababbabaabba -> ababbabaabbba
bababbabaaba -> ababbabaabba
bababbabaaa -> ababbabaaba

# < a,b | bababbababaaaaa=a >
bababbababaaaaa -> a

# < a,b | bababbababaaaba=a >
bababbababaaaba -> a
bababbababaaaa -> ababbababaaaba

# < a,b | bababbababaabaa=a >
bababbababaabaa -> a

# < a,b | bababbababaabba=a >
bababbababaabba -> a
bababbababaaba -> ababbababaabba
bababbababaaa -> ababbababaaba

# < a,b | bababbabababaaa=a >
bababbabababaaa -> a

# < a,b | bababbababababa=a >
bababbababababa -> a
bababbabababaa -> ababbababababa
bababbababaa -> abbababababa

# < a,b | bababbabababbaa=a >
bababbabababbaa -> a

# < a,b | bababbababbaaaa=a >
bababbababbaaaa -> a

# < a,b | bababbababbaaba=a >
bababbababbaaba -> a
bababbababbaaa -> ababbababbaaba

# < a,b | bababbababbabaa=a >
bababbababbabaa -> a

# < a,b | bababbababbbaaa=a >
bababbababbbaaa -> a

# < a,b | bababbababbbbaa=a >
bababbababbbbaa -> a

# < a,b | bababbabbaaaaaa=a >
bababbabbaaaaaa -> a

# < a,b | bababbabbaaaaba=a >
bababbabbaaaaba -> a
bababbabbaaaaa -> ababbabbaaaaba

# < a,b | bababbabbaaabaa=a >
bababbabbaaabaa -> a

# < a,b | bababbabbaaabba=a >
bababbabbaaabba -> a
bababbabbaaaba -> ababbabbaaabba
bababbabbaaaa -> ababbabbaaaba

# < a,b | bababbabbaabaaa=a >
bababbabbaabaaa -> a

# < a,b | bababbabbaababa=a >
bababbabbaababa -> a
bababbabbaabaa -> ababbabbaababa
bababbabbaaa -> abbabbaababa

# < a,b | bababbabbaabbaa=a >
bababbabbaabbaa -> a

# < a,b | bababbabbaabbba=a >
bababbabbaabbba -> a
bababbabbaabba -> ababbabbaabbba
bababbabbaaba -> ababbabbaabba
bababbabbaaa -> ababbabbaaba

# < a,b | bababbabbabaaaa=a >
bababbabbabaaaa -> a

# < a,b | bababbabbabaaba=a >
bababbabbabaaba -> a
bababbabbabaaa -> ababbabbabaaba

# < a,b | bababbabbababaa=a >
bababbabbababaa -> a

# < a,b | bababbabbabbaaa=a >
bababbabbabbaaa -> a

# < a,b | bababbabbabbaba=a >
bababbabbabbaba -> a
bababbabbaba -> abbabbabbaba
bababbaba -> abbabbaba
bababa -> abbaba
baa -> aba

# < a,b | bababbabbabbbaa=a >
bababbabbabbbaa -> a

# < a,b | bababbabbbaaaaa=a >
bababbabbbaaaaa -> a

# < a,b | bababbabbbaaaba=a >
bababbabbbaaaba -> a
bababbabbbaaaa -> ababbabbbaaaba

# < a,b | bababbabbbaabaa=a >
bababbabbbaabaa -> a

# < a,b | bababbabbbaabba=a >
bababbabbbaabba -> a
bababbabbbaaba -> ababbabbbaabba
bababbabbbaaa -> ababbabbbaaba

# < a,b | bababbabbbabaaa=a >
bababbabbbabaaa -> a

# < a,b | bababbabbbababa=a >
bababbabbbababa -> a
bababbabbbabaa -> ababbabbbababa
bababbabbbaa -> abbabbbababa

# < a,b | bababbabbbabbaa=a >
bababbabbbabbaa -> a

# < a,b | bababbabbbbaaaa=a >
bababbabbbbaaaa -> a

# < a,b | bababbabbbbaaba=a >
bababbabbbbaaba -> a
bababbabbbbaaa -> ababbabbbbaaba

# < a,b | bababbabbbbabaa=a >
bababbabbbbabaa -> a

# < a,b | bababbabbbbbaaa=a >
bababbabbbbbaaa -> a

# < a,b | bababbabbbbbbaa=a >
bababbabbbbbbaa -> a

# < a,b | bababbbaaaaaaaa=a >
bababbbaaaaaaaa -> a

# < a,b | bababbbaaaaaaba=a >
bababbbaaaaaaba -> a
bababbbaaaaaaa -> ababbbaaaaaaba

# < a,b | bababbbaaaaabaa=a >
bababbbaaaaabaa -> a

# < a,b | bababbbaaaaabba=a >
bababbbaaaaabba -> a
bababbbaaaaaba -> ababbbaaaaabba
bababbbaaaaaa -> ababbbaaaaaba

# < a,b | bababbbaaaabaaa=a >
bababbbaaaabaaa -> a

# < a,b | bababbbaaaababa=a >
bababbbaaaababa -> a
bababbbaaaabaa -> ababbbaaaababa
bababbbaaaaa -> abbbaaaababa

# < a,b | bababbbaaaabbaa=a >
bababbbaaaabbaa -> a

# < a,b | bababbbaaaabbba=a >
bababbbaaaabbba -> a
bababbbaaaabba -> ababbbaaaabbba
bababbbaaaaba -> ababbbaaaabba
bababbbaaaaa -> ababbbaaaaba

# < a,b | bababbbaaabaaaa=a >
bababbbaaabaaaa -> a

# < a,b | bababbbaaabaaba=a >
bababbbaaabaaba -> a
bababbbaaabaaa -> ababbbaaabaaba

# < a,b | bababbbaaababaa=a >
bababbbaaababaa -> a

# < a,b | bababbbaaabbaaa=a >
bababbbaaabbaaa -> a

# < a,b | bababbbaaabbaba=a >
bababbbaaabbaba -> a
bababbbaaabbaa -> ababbbaaabbaba
bababbbaaaba -> abbbaaabbaba
bababbbaaaa -> abbbaaabbaa

# < a,b | bababbbaaabbbaa=a >
bababbbaaabbbaa -> a

# < a,b | bababbbaaabbbba=a >
bababbbaaabbbba -> a
bababbbaaabbba -> ababbbaaabbbba
bababbbaaabba -> ababbbaaabbba
bababbbaaaba -> ababbbaaabba
bababbbaaaa -> ababbbaaaba

# < a,b | bababbbaabaaaaa=a >
bababbbaabaaaaa -> a

# < a,b | bababbbaabaaaba=a >
bababbbaabaaaba -> a
bababbbaabaaaa -> ababbbaabaaaba

# < a,b | bababbbaabaabaa=a >
bababbbaabaabaa -> a

# < a,b | bababbbaabaabba=a >
bababbbaabaabba -> a
bababbbaabaaba -> ababbbaabaabba
bababbbaabaaa -> ababbbaabaaba

# < a,b | bababbbaababaaa=a >
bababbbaababaaa -> a

# < a,b | bababbbaabababa=a >
bababbbaabababa -> a
bababbbaababaa -> ababbbaabababa
bababbbaabaa -> abbbaabababa

# < a,b | bababbbaababbaa=a >
bababbbaababbaa -> a

# < a,b | bababbbaabbaaaa=a >
bababbbaabbaaaa -> a

# < a,b | bababbbaabbaaba=a >
bababbbaabbaaba -> a
bababbbaabbaaa -> ababbbaabbaaba

# < a,b | bababbbaabbabaa=a >
bababbbaabbabaa -> a

# < a,b | bababbbaabbbaaa=a >
bababbbaabbbaaa -> a

# < a,b | bababbbaabbbbaa=a >
bababbbaabbbbaa -> a

# < a,b | bababbbaabbbbba=a >
bababbbaabbbbba -> a
bababbbaabbbba -> ababbbaabbbbba
bababbbaabbba -> ababbbaabbbba
bababbbaabba -> ababbbaabbba
bababbbaaba -> ababbbaabba
bababbbaaa -> ababbbaaba

# < a,b | bababbbabaaaaaa=a >
bababbbabaaaaaa -> a

# < a,b | bababbbabaaaaba=a >
bababbbabaaaaba -> a
bababbbabaaaaa -> ababbbabaaaaba

# < a,b | bababbbabaaabaa=a >
bababbbabaaabaa -> a

# < a,b | bababbbabaaabba=a >
bababbbabaaabba -> a
bababbbabaaaba -> ababbbabaaabba
bababbbabaaaa -> ababbbabaaaba

# < a,b | bababbbabaabaaa=a >
bababbbabaabaaa -> a

# < a,b | bababbbabaababa=a >
bababbbabaababa -> a
bababbbabaabaa -> ababbbabaababa
bababbbabaaa -> abbbabaababa

# < a,b | bababbbabaabbaa=a >
bababbbabaabbaa -> a

# < a,b | bababbbabaabbba=a >
bababbbabaabbba -> a
bababbbabaabba -> ababbbabaabbba
bababbbabaaba -> ababbbabaabba
bababbbabaaa -> ababbbabaaba

# < a,b | bababbbababaaaa=a >
bababbbababaaaa -> a

# < a,b | bababbbababaaba=a >
bababbbababaaba -> a
bababbbababaaa -> ababbbababaaba

# < a,b | bababbbabababaa=a >
bababbbabababaa -> a

# < a,b | bababbbababbaaa=a >
bababbbababbaaa -> a

# < a,b | bababbbababbaba=a >
bababbbababbaba -> a
bababbbababbaa -> ababbbababbaba
bababbbababa -> abbbababbaba
bababbbabaa -> abbbababbaa
bababbbaa -> abbbababa

# < a,b | bababbbababbbaa=a >
bababbbababbbaa -> a

# < a,b | bababbbabbaaaaa=a >
bababbbabbaaaaa -> a

# < a,b | bababbbabbaaaba=a >
bababbbabbaaaba -> a
bababbbabbaaaa -> ababbbabbaaaba

# < a,b | bababbbabbaabaa=a >
bababbbabbaabaa -> a

# < a,b | bababbbabbaabba=a >
bababbbabbaabba -> a
bababbbabbaaba -> ababbbabbaabba
bababbbabbaaa -> ababbbabbaaba

# < a,b | bababbbabbabaaa=a >
bababbbabbabaaa -> a

# < a,b | bababbbabbababa=a >
bababbbabbababa -> a
bababbbabbabaa -> ababbbabbababa
bababbbabbaa -> abbbabbababa

# < a,b | bababbbabbabbaa=a >
bababbbabbabbaa -> a

# < a,b | bababbbabbbaaaa=a >
bababbbabbbaaaa -> a

# < a,b | bababbbabbbaaba=a >
bababbbabbbaaba -> a
bababbbabbbaaa -> ababbbabbbaaba

# < a,b | bababbbabbbabaa=a >
bababbbabbbabaa -> a

# < a,b | bababbbabbbbaaa=a >
bababbbabbbbaaa -> a

# < a,b | bababbbabbbbbaa=a >
bababbbabbbbbaa -> a

# < a,b | bababbbbaaaaaaa=a >
bababbbbaaaaaaa -> a

# < a,b | bababbbbaaaaaba=a >
bababbbbaaaaaba -> a
bababbbbaaaaaa -> ababbbbaaaaaba

# < a,b | bababbbbaaaabaa=a >
bababbbbaaaabaa -> a

# < a,b | bababbbbaaaabba=a >
bababbbbaaaabba -> a
bababbbbaaaaba -> ababbbbaaaabba
bababbbbaaaaa -> ababbbbaaaaba

# < a,b | bababbbbaaabaaa=a >
bababbbbaaabaaa -> a

# < a,b | bababbbbaaababa=a >
bababbbbaaababa -> a
bababbbbaaabaa -> ababbbbaaababa
bababbbbaaaa -> abbbbaaababa

# < a,b | bababbbbaaabbaa=a >
bababbbbaaabbaa -> a

# < a,b | bababbbbaaabbba=a >
bababbbbaaabbba -> a
bababbbbaaabba -> ababbbbaaabbba
bababbbbaaaba -> ababbbbaaabba
bababbbbaaaa -> ababbbbaaaba

# < a,b | bababbbbaabaaaa=a >
bababbbbaabaaaa -> a

# < a,b | bababbbbaabaaba=a >
bababbbbaabaaba -> a
bababbbbaabaaa -> ababbbbaabaaba

# < a,b | bababbbbaababaa=a >
bababbbbaababaa -> a

# < a,b | bababbbbaabbaaa=a >
bababbbbaabbaaa -> a

# < a,b | bababbbbaabbaba=a >
bababbbbaabbaba -> a
bababbbbaabbaa -> ababbbbaabbaba
bababbbbaaba -> abbbbaabbaba
bababbbbaaa -> abbbbaabbaa

# < a,b | bababbbbaabbbaa=a >
bababbbbaabbbaa -> a

# < a,b | bababbbbaabbbba=a >
bababbbbaabbbba -> a
bababbbbaabbba -> ababbbbaabbbba
bababbbbaabba -> ababbbbaabbba
bababbbbaaba -> ababbbbaabba
bababbbbaaa -> ababbbbaaba

# < a,b | bababbbbabaaaaa=a >
bababbbbabaaaaa -> a

# < a,b | bababbbbabaaaba=a >
bababbbbabaaaba -> a
bababbbbabaaaa -> ababbbbabaaaba

# < a,b | bababbbbabaabaa=a >
bababbbbabaabaa -> a

# < a,b | bababbbbabaabba=a >
bababbbbabaabba -> a
bababbbbabaaba -> ababbbbabaabba
bababbbbabaaa -> ababbbbabaaba

# < a,b | bababbbbababaaa=a >
bababbbbababaaa -> a

# < a,b | bababbbbabababa=a >
bababbbbabababa -> a
bababbbbababaa -> ababbbbabababa
bababbbbabaa -> abbbbabababa

# < a,b | bababbbbababbaa=a >
bababbbbababbaa -> a

# < a,b | bababbbbabbaaaa=a >
bababbbbabbaaaa -> a

# < a,b | bababbbbabbaaba=a >
bababbbbabbaaba -> a
bababbbbabbaaa -> ababbbbabbaaba

# < a,b | bababbbbabbabaa=a >
bababbbbabbabaa -> a

# < a,b | bababbbbabbbaaa=a >
bababbbbabbbaaa -> a

# < a,b | bababbbbabbbbaa=a >
bababbbbabbbbaa -> a

# < a,b | bababbbbbaaaaaa=a >
bababbbbbaaaaaa -> a

# < a,b | bababbbbbaaaaba=a >
bababbbbbaaaaba -> a
bababbbbbaaaaa -> ababbbbbaaaaba

# < a,b | bababbbbbaaabaa=a >
bababbbbbaaabaa -> a

# < a,b | bababbbbbaaabba=a >
bababbbbbaaabba -> a
bababbbbbaaaba -> ababbbbbaaabba
bababbbbbaaaa -> ababbbbbaaaba

# < a,b | bababbbbbaabaaa=a >
bababbbbbaabaaa -> a

# < a,b | bababbbbbaababa=a >
bababbbbbaababa -> a
bababbbbbaabaa -> ababbbbbaababa
bababbbbbaaa -> abbbbbaababa

# < a,b | bababbbbbaabbaa=a >
bababbbbbaabbaa -> a

# < a,b | bababbbbbaabbba=a >
bababbbbbaabbba -> a
bababbbbbaabba -> ababbbbbaabbba
bababbbbbaaba -> ababbbbbaabba
bababbbbbaaa -> ababbbbbaaba

# < a,b | bababbbbbabaaaa=a >
bababbbbbabaaaa -> a

# < a,b | bababbbbbabaaba=a >
bababbbbbabaaba -> a
bababbbbbabaaa -> ababbbbbabaaba

# < a,b | bababbbbbababaa=a >
bababbbbbababaa -> a

# < a,b | bababbbbbabbaaa=a >
bababbbbbabbaaa -> a

# < a,b | bababbbbbabbbaa=a >
bababbbbbabbbaa -> a

# < a,b | bababbbbbbaaaaa=a >
bababbbbbbaaaaa -> a

# < a,b | bababbbbbbaaaba=a >
bababbbbbbaaaba -> a
bababbbbbbaaaa -> ababbbbbbaaaba

# < a,b | bababbbbbbaabaa=a >
bababbbbbbaabaa -> a

# < a,b | bababbbbbbaabba=a >
bababbbbbbaabba -> a
bababbbbbbaaba -> ababbbbbbaabba
bababbbbbbaaa -> ababbbbbbaaba

# < a,b | bababbbbbbabaaa=a >
bababbbbbbabaaa -> a

# < a,b | bababbbbbbababa=a >
bababbbbbbababa -> a
bababbbbbbabaa -> ababbbbbbababa
bababbbbbbaa -> abbbbbbababa

# < a,b | bababbbbbbabbaa=a >
bababbbbbbabbaa -> a

# < a,b | bababbbbbbbaaaa=a >
bababbbbbbbaaaa -> a

# < a,b | bababbbbbbbaaba=a >
bababbbbbbbaaba -> a
bababbbbbbbaaa -> ababbbbbbbaaba

# < a,b | bababbbbbbbabaa=a >
bababbbbbbbabaa -> a

# < a,b | bababbbbbbbbaaa=a >
bababbbbbbbbaaa -> a

# < a,b | bababbbbbbbbbaa=a >
bababbbbbbbbbaa -> a

# < a,b | babbaaaaaaaaaaa=a >
babbaaaaaaaaaaa -> a

# < a,b | babbaaaaaaaaaba=a >
babbaaaaaaaaaba -> a
babbaaaaaaaaaa -> abbaaaaaaaaaba

# < a,b | babbaaaaaaaabaa=a >
babbaaaaaaaabaa -> a

# < a,b | babbaaaaaaaabba=a >
babbaaaaaaaabba -> a
babbaaaaaaaaba -> abbaaaaaaaabba
babbaaaaaaaaa -> abbaaaaaaaaba

# < a,b | babbaaaaaaabaaa=a >
babbaaaaaaabaaa -> a

# < a,b | babbaaaaaaababa=a >
babbaaaaaaababa -> a
babbaaaaaaabaa -> abbaaaaaaababa

# < a,b | babbaaaaaaabbaa=a >
babbaaaaaaabbaa -> a

# < a,b | babbaaaaaaabbba=a >
babbaaaaaaabbba -> a
babbaaaaaaabba -> abbaaaaaaabbba
babbaaaaaaaba -> abbaaaaaaabba
babbaaaaaaaa -> abbaaaaaaaba

# < a,b | babbaaaaaabaaaa=a >
babbaaaaaabaaaa -> a

# < a,b | babbaaaaaabaaba=a >
babbaaaaaabaaba -> a
babbaaaaaabaaa -> abbaaaaaabaaba

# < a,b | babbaaaaaababaa=a >
babbaaaaaababaa -> a

# < a,b | babbaaaaaababba=a >
babbaaaaaababba -> a
babbaaaaaababa -> abbaaaaaababba
babbaaaaaaa -> aaaaaababba
babbaaaaaabaa -> abbaaaaaababa

# < a,b | babbaaaaaabbaaa=a >
babbaaaaaabbaaa -> a

# < a,b | babbaaaaaabbaba=a >
babbaaaaaabbaba -> a
babbaaaaaabbaa -> abbaaaaaabbaba

# < a,b | babbaaaaaabbbaa=a >
babbaaaaaabbbaa -> a

# < a,b | babbaaaaaabbbba=a >
babbaaaaaabbbba -> a
babbaaaaaabbba -> abbaaaaaabbbba
babbaaaaaabba -> abbaaaaaabbba
babbaaaaaaba -> abbaaaaaabba
babbaaaaaaa -> abbaaaaaaba

# < a,b | babbaaaaabaaaaa=a >
babbaaaaabaaaaa -> a

# < a,b | babbaaaaabaaaba=a >
babbaaaaabaaaba -> a
babbaaaaabaaaa -> abbaaaaabaaaba

# < a,b | babbaaaaabaabaa=a >
babbaaaaabaabaa -> a

# < a,b | babbaaaaabaabba=a >
babbaaaaabaabba -> a
babbaaaaabaaba -> abbaaaaabaabba
babbaaaaabaaa -> abbaaaaabaaba

# < a,b | babbaaaaababaaa=a >
babbaaaaababaaa -> a

# < a,b | babbaaaaabababa=a >
babbaaaaabababa -> a
babbaaaaababaa -> abbaaaaabababa

# < a,b | babbaaaaababbaa=a >
babbaaaaababbaa -> a
babbaaaaaa -> aaaababbaa

# < a,b | babbaaaaabbaaaa=a >
babbaaaaabbaaaa -> a

# < a,b | babbaaaaabbaaba=a >
babbaaaaabbaaba -> a
babbaaaaabbaaa -> abbaaaaabbaaba

# < a,b | babbaaaaabbabaa=a >
babbaaaaabbabaa -> a

# < a,b | babbaaaaabbabba=a >
babbaaaaabbabba -> a
babbaaaaabbaba -> abbaaaaabbabba
babbaaaaaba -> aaaaabbabba
babbaaaaabbaa -> abbaaaaabbaba
babbaaaaaa -> aaaaabbaba

# < a,b | babbaaaaabbbaaa=a >
babbaaaaabbbaaa -> a

# < a,b | babbaaaaabbbaba=a >
babbaaaaabbbaba -> a
babbaaaaabbbaa -> abbaaaaabbbaba

# < a,b | babbaaaaabbbbaa=a >
babbaaaaabbbbaa -> a

# < a,b | babbaaaaabbbbba=a >
babbaaaaabbbbba -> a
babbaaaaabbbba -> abbaaaaabbbbba
babbaaaaabbba -> abbaaaaabbbba
babbaaaaabba -> abbaaaaabbba
babbaaaaaba -> abbaaaaabba
babbaaaaaa -> abbaaaaaba

# < a,b | babbaaaabaaaaaa=a >
babbaaaabaaaaaa -> a

# < a,b | babbaaaabaaaaba=a >
babbaaaabaaaaba -> a
babbaaaabaaaaa -> abbaaaabaaaaba

# < a,b | babbaaaabaaabaa=a >
babbaaaabaaabaa -> a

# < a,b | babbaaaabaaabba=a >
babbaaaabaaabba -> a
babbaaaabaaaba -> abbaaaabaaabba
babbaaaabaaaa -> abbaaaabaaaba

# < a,b | babbaaaabaabaaa=a >
babbaaaabaabaaa -> a

# < a,b | babbaaaabaababa=a >
babbaaaabaababa -> a
babbaaaabaabaa -> abbaaaabaababa

# < a,b | babbaaaabaabbaa=a >
babbaaaabaabbaa -> a

# < 

04_failures.txt