Created
December 19, 2020 14:59
-
-
Save vijfhoek/ac53782346b23e703c2873d5e7ad9441 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from typing import Tuple | |
| def rule_0(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_8(r) | |
| valid_1, r = rule_11(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_1(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_7(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_20(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_2(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_64(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_77(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_3(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_127(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_67(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_4(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_104(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_9(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_5(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_109(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_39(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_6(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_33(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_34(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_7(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_86(r) | |
| valid_1, r = rule_90(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_8(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_42(r) | |
| if all(( | |
| valid_0, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_9(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_82(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_16(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_10(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_90(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_11(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_42(r) | |
| valid_1, r = rule_31(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_12(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_39(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_13(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_38(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_21(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_14(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_95(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_15(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_83(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_51(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_16(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_39(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_54(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_17(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_119(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_12(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_18(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_135(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_19(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_102(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_55(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_20(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_134(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_21(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_90(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_135(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_22(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_113(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_23(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_54(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_30(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_24(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_56(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_128(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_25(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_62(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_45(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_26(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_27(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_54(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_39(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_28(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_30(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_30(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_29(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_96(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_13(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_30(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_31(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_108(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_85(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_32(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_86(r) | |
| valid_1, r = rule_39(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_33(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_116(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_34(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_26(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_47(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_35(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_54(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_113(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_36(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_10(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_76(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_37(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_3(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_118(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_38(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_39(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_40(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_125(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_71(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_41(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_36(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_53(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_42(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_100(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_121(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_43(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_113(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_44(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_61(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_1(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_45(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_90(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_46(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_39(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_47(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_48(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_5(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_27(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_49(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_50(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_80(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_136(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_51(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_131(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_106(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_52(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_109(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_53(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_10(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_49(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_54(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_55(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_60(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_98(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_56(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_39(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_57(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_25(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_73(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_58(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_47(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_59(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_88(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_60(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_95(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_84(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_61(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_131(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_18(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_62(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_109(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_135(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_63(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_64(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_63(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_79(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_65(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_30(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_66(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_78(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_107(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_67(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_113(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_54(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_68(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_90(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_69(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_132(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_101(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_70(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_130(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_48(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_71(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_52(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_103(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_72(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_44(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_69(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_73(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_94(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_92(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_74(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_134(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_47(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_75(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_70(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_57(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_76(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_113(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_135(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_77(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_46(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_23(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_78(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_28(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_65(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_79(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_88(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_80(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_115(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_127(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_81(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_6(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_24(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_82(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_95(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_83(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_22(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_111(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_84(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_86(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_85(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_120(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_75(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_86(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_87(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_90(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_26(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_88(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_86(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_89(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_66(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_37(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_90(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_86(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_91(s: str) -> Tuple[bool, str]: | |
| if s[0] == 'b': | |
| return True, s[1:] | |
| return False, s | |
| def rule_92(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_90(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_93(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_15(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_81(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_94(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_84(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_95(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_96(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_14(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_58(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_97(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_19(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_110(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_98(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_39(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_99(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_86(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_100(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_97(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_89(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_101(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_126(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_59(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_102(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_99(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_117(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_103(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_104(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_32(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_43(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_105(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_88(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_109(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_106(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_84(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_113(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_107(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_123(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_68(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_108(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_93(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_72(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_109(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_86(r) | |
| valid_1, r = rule_86(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_110(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_112(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_17(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_111(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_47(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_134(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_112(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_74(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_52(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_113(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_114(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_2(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_41(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_115(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_135(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_90(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_116(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_117(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_135(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_30(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_118(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_122(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_105(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_119(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_47(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_109(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_120(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_40(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_4(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_121(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_114(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_133(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_122(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_47(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_123(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_88(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_47(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_124(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_135(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_134(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_125(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_87(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_59(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_126(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_127(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_30(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_95(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_128(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_54(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_84(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_129(s: str) -> Tuple[bool, str]: | |
| if s[0] == 'a': | |
| return True, s[1:] | |
| return False, s | |
| def rule_130(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_23(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_35(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_131(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_113(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_90(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_132(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_124(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_59(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_133(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_50(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_29(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_134(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_86(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_135(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_129(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_91(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def rule_136(s: str) -> Tuple[bool, str]: | |
| r = s | |
| valid_0, r = rule_91(r) | |
| valid_1, r = rule_115(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| r = s | |
| valid_0, r = rule_129(r) | |
| valid_1, r = rule_7(r) | |
| if all(( | |
| valid_0, | |
| valid_1, | |
| )): | |
| return True, r | |
| return False, s | |
| def validate(s): | |
| if rule_0(s) == (True, ''): | |
| return True | |
| if rule_1(s) == (True, ''): | |
| return True | |
| if rule_2(s) == (True, ''): | |
| return True | |
| if rule_3(s) == (True, ''): | |
| return True | |
| if rule_4(s) == (True, ''): | |
| return True | |
| if rule_5(s) == (True, ''): | |
| return True | |
| if rule_6(s) == (True, ''): | |
| return True | |
| if rule_7(s) == (True, ''): | |
| return True | |
| if rule_8(s) == (True, ''): | |
| return True | |
| if rule_9(s) == (True, ''): | |
| return True | |
| if rule_10(s) == (True, ''): | |
| return True | |
| if rule_11(s) == (True, ''): | |
| return True | |
| if rule_12(s) == (True, ''): | |
| return True | |
| if rule_13(s) == (True, ''): | |
| return True | |
| if rule_14(s) == (True, ''): | |
| return True | |
| if rule_15(s) == (True, ''): | |
| return True | |
| if rule_16(s) == (True, ''): | |
| return True | |
| if rule_17(s) == (True, ''): | |
| return True | |
| if rule_18(s) == (True, ''): | |
| return True | |
| if rule_19(s) == (True, ''): | |
| return True | |
| if rule_20(s) == (True, ''): | |
| return True | |
| if rule_21(s) == (True, ''): | |
| return True | |
| if rule_22(s) == (True, ''): | |
| return True | |
| if rule_23(s) == (True, ''): | |
| return True | |
| if rule_24(s) == (True, ''): | |
| return True | |
| if rule_25(s) == (True, ''): | |
| return True | |
| if rule_26(s) == (True, ''): | |
| return True | |
| if rule_27(s) == (True, ''): | |
| return True | |
| if rule_28(s) == (True, ''): | |
| return True | |
| if rule_29(s) == (True, ''): | |
| return True | |
| if rule_30(s) == (True, ''): | |
| return True | |
| if rule_31(s) == (True, ''): | |
| return True | |
| if rule_32(s) == (True, ''): | |
| return True | |
| if rule_33(s) == (True, ''): | |
| return True | |
| if rule_34(s) == (True, ''): | |
| return True | |
| if rule_35(s) == (True, ''): | |
| return True | |
| if rule_36(s) == (True, ''): | |
| return True | |
| if rule_37(s) == (True, ''): | |
| return True | |
| if rule_38(s) == (True, ''): | |
| return True | |
| if rule_39(s) == (True, ''): | |
| return True | |
| if rule_40(s) == (True, ''): | |
| return True | |
| if rule_41(s) == (True, ''): | |
| return True | |
| if rule_42(s) == (True, ''): | |
| return True | |
| if rule_43(s) == (True, ''): | |
| return True | |
| if rule_44(s) == (True, ''): | |
| return True | |
| if rule_45(s) == (True, ''): | |
| return True | |
| if rule_46(s) == (True, ''): | |
| return True | |
| if rule_47(s) == (True, ''): | |
| return True | |
| if rule_48(s) == (True, ''): | |
| return True | |
| if rule_49(s) == (True, ''): | |
| return True | |
| if rule_50(s) == (True, ''): | |
| return True | |
| if rule_51(s) == (True, ''): | |
| return True | |
| if rule_52(s) == (True, ''): | |
| return True | |
| if rule_53(s) == (True, ''): | |
| return True | |
| if rule_54(s) == (True, ''): | |
| return True | |
| if rule_55(s) == (True, ''): | |
| return True | |
| if rule_56(s) == (True, ''): | |
| return True | |
| if rule_57(s) == (True, ''): | |
| return True | |
| if rule_58(s) == (True, ''): | |
| return True | |
| if rule_59(s) == (True, ''): | |
| return True | |
| if rule_60(s) == (True, ''): | |
| return True | |
| if rule_61(s) == (True, ''): | |
| return True | |
| if rule_62(s) == (True, ''): | |
| return True | |
| if rule_63(s) == (True, ''): | |
| return True | |
| if rule_64(s) == (True, ''): | |
| return True | |
| if rule_65(s) == (True, ''): | |
| return True | |
| if rule_66(s) == (True, ''): | |
| return True | |
| if rule_67(s) == (True, ''): | |
| return True | |
| if rule_68(s) == (True, ''): | |
| return True | |
| if rule_69(s) == (True, ''): | |
| return True | |
| if rule_70(s) == (True, ''): | |
| return True | |
| if rule_71(s) == (True, ''): | |
| return True | |
| if rule_72(s) == (True, ''): | |
| return True | |
| if rule_73(s) == (True, ''): | |
| return True | |
| if rule_74(s) == (True, ''): | |
| return True | |
| if rule_75(s) == (True, ''): | |
| return True | |
| if rule_76(s) == (True, ''): | |
| return True | |
| if rule_77(s) == (True, ''): | |
| return True | |
| if rule_78(s) == (True, ''): | |
| return True | |
| if rule_79(s) == (True, ''): | |
| return True | |
| if rule_80(s) == (True, ''): | |
| return True | |
| if rule_81(s) == (True, ''): | |
| return True | |
| if rule_82(s) == (True, ''): | |
| return True | |
| if rule_83(s) == (True, ''): | |
| return True | |
| if rule_84(s) == (True, ''): | |
| return True | |
| if rule_85(s) == (True, ''): | |
| return True | |
| if rule_86(s) == (True, ''): | |
| return True | |
| if rule_87(s) == (True, ''): | |
| return True | |
| if rule_88(s) == (True, ''): | |
| return True | |
| if rule_89(s) == (True, ''): | |
| return True | |
| if rule_90(s) == (True, ''): | |
| return True | |
| if rule_91(s) == (True, ''): | |
| return True | |
| if rule_92(s) == (True, ''): | |
| return True | |
| if rule_93(s) == (True, ''): | |
| return True | |
| if rule_94(s) == (True, ''): | |
| return True | |
| if rule_95(s) == (True, ''): | |
| return True | |
| if rule_96(s) == (True, ''): | |
| return True | |
| if rule_97(s) == (True, ''): | |
| return True | |
| if rule_98(s) == (True, ''): | |
| return True | |
| if rule_99(s) == (True, ''): | |
| return True | |
| if rule_100(s) == (True, ''): | |
| return True | |
| if rule_101(s) == (True, ''): | |
| return True | |
| if rule_102(s) == (True, ''): | |
| return True | |
| if rule_103(s) == (True, ''): | |
| return True | |
| if rule_104(s) == (True, ''): | |
| return True | |
| if rule_105(s) == (True, ''): | |
| return True | |
| if rule_106(s) == (True, ''): | |
| return True | |
| if rule_107(s) == (True, ''): | |
| return True | |
| if rule_108(s) == (True, ''): | |
| return True | |
| if rule_109(s) == (True, ''): | |
| return True | |
| if rule_110(s) == (True, ''): | |
| return True | |
| if rule_111(s) == (True, ''): | |
| return True | |
| if rule_112(s) == (True, ''): | |
| return True | |
| if rule_113(s) == (True, ''): | |
| return True | |
| if rule_114(s) == (True, ''): | |
| return True | |
| if rule_115(s) == (True, ''): | |
| return True | |
| if rule_116(s) == (True, ''): | |
| return True | |
| if rule_117(s) == (True, ''): | |
| return True | |
| if rule_118(s) == (True, ''): | |
| return True | |
| if rule_119(s) == (True, ''): | |
| return True | |
| if rule_120(s) == (True, ''): | |
| return True | |
| if rule_121(s) == (True, ''): | |
| return True | |
| if rule_122(s) == (True, ''): | |
| return True | |
| if rule_123(s) == (True, ''): | |
| return True | |
| if rule_124(s) == (True, ''): | |
| return True | |
| if rule_125(s) == (True, ''): | |
| return True | |
| if rule_126(s) == (True, ''): | |
| return True | |
| if rule_127(s) == (True, ''): | |
| return True | |
| if rule_128(s) == (True, ''): | |
| return True | |
| if rule_129(s) == (True, ''): | |
| return True | |
| if rule_130(s) == (True, ''): | |
| return True | |
| if rule_131(s) == (True, ''): | |
| return True | |
| if rule_132(s) == (True, ''): | |
| return True | |
| if rule_133(s) == (True, ''): | |
| return True | |
| if rule_134(s) == (True, ''): | |
| return True | |
| if rule_135(s) == (True, ''): | |
| return True | |
| if rule_136(s) == (True, ''): | |
| return True | |
| return False | |
| if __name__ == '__main__': | |
| part1 = 0 | |
| if (result := validate('babaaaabbbbababaaaabaabb')): | |
| part1 += 1 | |
| print('babaaaabbbbababaaaabaabb:', result) | |
| if (result := validate('aaabaaababbaaabbbbbbabaabbaabababababbaa')): | |
| part1 += 1 | |
| print('aaabaaababbaaabbbbbbabaabbaabababababbaa:', result) | |
| if (result := validate('aaabbbbabbabaaaabbaabaab')): | |
| part1 += 1 | |
| print('aaabbbbabbabaaaabbaabaab:', result) | |
| if (result := validate('babaabbabbbbbaabbabaabab')): | |
| part1 += 1 | |
| print('babaabbabbbbbaabbabaabab:', result) | |
| if (result := validate('abaabaabbbabaabbabbbabab')): | |
| part1 += 1 | |
| print('abaabaabbbabaabbabbbabab:', result) | |
| if (result := validate('abbaababbbababbabbaabaabaaabaaabbbbbbbba')): | |
| part1 += 1 | |
| print('abbaababbbababbabbaabaabaaabaaabbbbbbbba:', result) | |
| if (result := validate('bbbbabbbbbaaaabbbbbbabaabbabbbaaaabbaaabbaabbbabbaaaabaa')): | |
| part1 += 1 | |
| print('bbbbabbbbbaaaabbbbbbabaabbabbbaaaabbaaabbaabbbabbaaaabaa:', result) | |
| if (result := validate('bbbbababaaabbababaaaabab')): | |
| part1 += 1 | |
| print('bbbbababaaabbababaaaabab:', result) | |
| if (result := validate('bbbabababaabbaaaabbbaaaa')): | |
| part1 += 1 | |
| print('bbbabababaabbaaaabbbaaaa:', result) | |
| if (result := validate('aaabbbbaaaabaabaabaababbbaabbaab')): | |
| part1 += 1 | |
| print('aaabbbbaaaabaabaabaababbbaabbaab:', result) | |
| if (result := validate('bbabbaabbabbbbabaaabaaaa')): | |
| part1 += 1 | |
| print('bbabbaabbabbbbabaaabaaaa:', result) | |
| if (result := validate('bbbaaababbaabbbabaaabbbb')): | |
| part1 += 1 | |
| print('bbbaaababbaabbbabaaabbbb:', result) | |
| if (result := validate('baabbbaabaaabbaabaabbbabaaaaabbbaabbbbbababbaabbbbbabaababbbbbbabbbabaaaaabaabbbababaaaa')): | |
| part1 += 1 | |
| print('baabbbaabaaabbaabaabbbabaaaaabbbaabbbbbababbaabbbbbabaababbbbbbabbbabaaaaabaabbbababaaaa:', result) | |
| if (result := validate('abbabababaaaabbabbabbbbbabaaababaaaaaabb')): | |
| part1 += 1 | |
| print('abbabababaaaabbabbabbbbbabaaababaaaaaabb:', result) | |
| if (result := validate('aabbaabbbaabbbbaababbbbbbbbbaaaa')): | |
| part1 += 1 | |
| print('aabbaabbbaabbbbaababbbbbbbbbaaaa:', result) | |
| if (result := validate('abaaabbbbababbabbaaabbaa')): | |
| part1 += 1 | |
| print('abaaabbbbababbabbaaabbaa:', result) | |
| if (result := validate('bbbaababaabaaabaabbaaabbaaaaabbbbbbbabbabaabaaaa')): | |
| part1 += 1 | |
| print('bbbaababaabaaabaabbaaabbaaaaabbbbbbbabbabaabaaaa:', result) | |
| if (result := validate('bbaaabaaabbaabbbabaaaaaa')): | |
| part1 += 1 | |
| print('bbaaabaaabbaabbbabaaaaaa:', result) | |
| if (result := validate('abbaabaaababababbabaabab')): | |
| part1 += 1 | |
| print('abbaabaaababababbabaabab:', result) | |
| if (result := validate('bbbbabaaaabbabbababbbaba')): | |
| part1 += 1 | |
| print('bbbbabaaaabbabbababbbaba:', result) | |
| if (result := validate('abaababbaaabbbbbbaaabbabbaabbbaaaababaaababbbabbbbbbbbbb')): | |
| part1 += 1 | |
| print('abaababbaaabbbbbbaaabbabbaabbbaaaababaaababbbabbbbbbbbbb:', result) | |
| if (result := validate('baaabbababaababbbbbbabaaabbaabba')): | |
| part1 += 1 | |
| print('baaabbababaababbbbbbabaaabbaabba:', result) | |
| if (result := validate('aaaabababbbbaababababbbbabbaabababbaaabbbabbaabb')): | |
| part1 += 1 | |
| print('aaaabababbbbaababababbbbabbaabababbaaabbbabbaabb:', result) | |
| if (result := validate('baaaaabaabbbbabaabaabbaa')): | |
| part1 += 1 | |
| print('baaaaabaabbbbabaabaabbaa:', result) | |
| if (result := validate('abaaabbaababaaaaaabaaaaa')): | |
| part1 += 1 | |
| print('abaaabbaababaaaaaabaaaaa:', result) | |
| if (result := validate('bbaabbbbbbbaaabbaaabaabb')): | |
| part1 += 1 | |
| print('bbaabbbbbbbaaabbaaabaabb:', result) | |
| if (result := validate('baaaaaaaabaaabbabaaaaaab')): | |
| part1 += 1 | |
| print('baaaaaaaabaaabbabaaaaaab:', result) | |
| if (result := validate('ababaabbbbaabbbbbabbaabb')): | |
| part1 += 1 | |
| print('ababaabbbbaabbbbbabbaabb:', result) | |
| if (result := validate('ababaabbabaabbbbbbaaaabbaaaaaabbabaaaaaa')): | |
| part1 += 1 | |
| print('ababaabbabaabbbbbbaaaabbaaaaaabbabaaaaaa:', result) | |
| if (result := validate('bbbbbbaaaabbabbabbabaabbbaabaaabaaaabaabaaabbbabaababbbb')): | |
| part1 += 1 | |
| print('bbbbbbaaaabbabbabbabaabbbaabaaabaaaabaabaaabbbabaababbbb:', result) | |
| if (result := validate('babbbaaaaaabbabbbaababbaabaabaabaabbaabaaaaaabaabababaab')): | |
| part1 += 1 | |
| print('babbbaaaaaabbabbbaababbaabaabaabaabbaabaaaaaabaabababaab:', result) | |
| if (result := validate('bbbaabaabaabbaaabbbbbbaaabbaaaba')): | |
| part1 += 1 | |
| print('bbbaabaabaabbaaabbbbbbaaabbaaaba:', result) | |
| if (result := validate('abaabbbbbbbabbbbbbbaaabaabbbbbabaabaabbb')): | |
| part1 += 1 | |
| print('abaabbbbbbbabbbbbbbaaabaabbbbbabaabaabbb:', result) | |
| if (result := validate('abbbaaabbbabbbbbababbaab')): | |
| part1 += 1 | |
| print('abbbaaabbbabbbbbababbaab:', result) | |
| if (result := validate('bbabbbaaabbbbabaaaaabbbbaaaaababbabbbbbaababaabaabaababa')): | |
| part1 += 1 | |
| print('bbabbbaaabbbbabaaaaabbbbaaaaababbabbbbbaababaabaabaababa:', result) | |
| if (result := validate('aababaaabbabbbbabababbabaaaabbbbbbbbbbbabbbaabbabaaabbbbaaabbabb')): | |
| part1 += 1 | |
| print('aababaaabbabbbbabababbabaaaabbbbbbbbbbbabbbaabbabaaabbbbaaabbabb:', result) | |
| if (result := validate('abababbbbababbbbaabbabbabbababbb')): | |
| part1 += 1 | |
| print('abababbbbababbbbaabbabbabbababbb:', result) | |
| if (result := validate('abbabbaabbaabbbbbaabbaaaaabbaaaabbbaabbabbbbaabbaabbabab')): | |
| part1 += 1 | |
| print('abbabbaabbaabbbbbaabbaaaaabbaaaabbbaabbabbbbaabbaabbabab:', result) | |
| if (result := validate('aabababaabaaabbabababbbbbbbbaaba')): | |
| part1 += 1 | |
| print('aabababaabaaabbabababbbbbbbbaaba:', result) | |
| if (result := validate('bbabbabbbbaabbaaaaaabbbbbbababaabbaababa')): | |
| part1 += 1 | |
| print('bbabbabbbbaabbaaaaaabbbbbbababaabbaababa:', result) | |
| if (result := validate('bbaabaababaaabbabbbbbaababaabaabbaabaabb')): | |
| part1 += 1 | |
| print('bbaabaababaaabbabbbbbaababaabaabbaabaabb:', result) | |
| if (result := validate('aababbaabbbbaababaaabaab')): | |
| part1 += 1 | |
| print('aababbaabbbbaababaaabaab:', result) | |
| if (result := validate('baabaabaaabbabaaaaababbb')): | |
| part1 += 1 | |
| print('baabaabaaabbabaaaaababbb:', result) | |
| if (result := validate('aaaabbbbaabbaaabbbaabbbaabbabbaabbaaaabbbbaaaababababababaaaaaab')): | |
| part1 += 1 | |
| print('aaaabbbbaabbaaabbbaabbbaabbabbaabbaaaabbbbaaaababababababaaaaaab:', result) | |
| if (result := validate('baaaabbabaaabbbaaabaabab')): | |
| part1 += 1 | |
| print('baaaabbabaaabbbaaabaabab:', result) | |
| if (result := validate('aabbabbaaabbabbbabbbbaaa')): | |
| part1 += 1 | |
| print('aabbabbaaabbabbbabbbbaaa:', result) | |
| if (result := validate('aaabbbbbbaaaabbabaabbaab')): | |
| part1 += 1 | |
| print('aaabbbbbbaaaabbabaabbaab:', result) | |
| if (result := validate('babaabbaabbbaaababbbbbaa')): | |
| part1 += 1 | |
| print('babaabbaabbbaaababbbbbaa:', result) | |
| if (result := validate('abaababbabaabbabbaaababbbabaaaaa')): | |
| part1 += 1 | |
| print('abaababbabaabbabbaaababbbabaaaaa:', result) | |
| if (result := validate('bbaababbbbbabbbbbababbba')): | |
| part1 += 1 | |
| print('bbaababbbbbabbbbbababbba:', result) | |
| if (result := validate('aababbaaaaabbbaaaaababbabbbababbbbaababbabaaaabbaabbabaa')): | |
| part1 += 1 | |
| print('aababbaaaaabbbaaaaababbabbbababbbbaababbabaaaabbaabbabaa:', result) | |
| if (result := validate('aaabbabbababaaaabbaabaaa')): | |
| part1 += 1 | |
| print('aaabbabbababaaaabbaabaaa:', result) | |
| if (result := validate('bbaabbaaabababbbbbabaaaabaaabbabababaaaaababbbaaababbabb')): | |
| part1 += 1 | |
| print('bbaabbaaabababbbbbabaaaabaaabbabababaaaaababbbaaababbabb:', result) | |
| if (result := validate('aabaaabaaababbaabbaabbbbababababbababbaa')): | |
| part1 += 1 | |
| print('aabaaabaaababbaabbaabbbbababababbababbaa:', result) | |
| if (result := validate('babaaabbbbabaabbbbaababbbaaaaabb')): | |
| part1 += 1 | |
| print('babaaabbbbabaabbbbaababbbaaaaabb:', result) | |
| if (result := validate('bbbbbabaaaaaabbababbabaabbaaabbb')): | |
| part1 += 1 | |
| print('bbbbbabaaaaaabbababbabaabbaaabbb:', result) | |
| if (result := validate('aaabbbbabbaabaabaabaabaa')): | |
| part1 += 1 | |
| print('aaabbbbabbaabaabaabaabaa:', result) | |
| if (result := validate('abababaaaaaabababaabaabb')): | |
| part1 += 1 | |
| print('abababaaaaaabababaabaabb:', result) | |
| if (result := validate('baabbabaabbbaaabbabbbbbb')): | |
| part1 += 1 | |
| print('baabbabaabbbaaabbabbbbbb:', result) | |
| if (result := validate('abababbbaaabbbbbbbaabaaa')): | |
| part1 += 1 | |
| print('abababbbaaabbbbbbbaabaaa:', result) | |
| if (result := validate('abaaabbbbbabaaaabaaaabab')): | |
| part1 += 1 | |
| print('abaaabbbbbabaaaabaaaabab:', result) | |
| if (result := validate('aababababaaabbabbbaaaaba')): | |
| part1 += 1 | |
| print('aababababaaabbabbbaaaaba:', result) | |
| if (result := validate('abababbbbbbbbaabbabbaaaa')): | |
| part1 += 1 | |
| print('abababbbbbbbbaabbabbaaaa:', result) | |
| if (result := validate('bbaabbaabaabaabbbabaaababbaaabaababbbaba')): | |
| part1 += 1 | |
| print('bbaabbaabaabaabbbabaaababbaaabaababbbaba:', result) | |
| if (result := validate('aaababaabbabaaaaabbabbbaabbabbbbababbbbbbbabbbabaaabbaaa')): | |
| part1 += 1 | |
| print('aaababaabbabaaaaabbabbbaabbabbbbababbbbbbbabbbabaaabbaaa:', result) | |
| if (result := validate('abbabababbbbababbbaaabaa')): | |
| part1 += 1 | |
| print('abbabababbbbababbbaaabaa:', result) | |
| if (result := validate('babbbbbaabaaabbbabbaaaababaabbbbbbabbabbbbbabbaa')): | |
| part1 += 1 | |
| print('babbbbbaabaaabbbabbaaaababaabbbbbbabbabbbbbabbaa:', result) | |
| if (result := validate('baabbabbaaabaaabbaabbbbbbaabbbabaabaabaaaabbaababaaaabaaaaaababbbbbbbaaabaaaabbb')): | |
| part1 += 1 | |
| print('baabbabbaaabaaabbaabbbbbbaabbbabaabaabaaaabbaababaaaabaaaaaababbbbbbbaaabaaaabbb:', result) | |
| if (result := validate('babaababbabbaabaaaabaabb')): | |
| part1 += 1 | |
| print('babaababbabbaabaaaabaabb:', result) | |
| if (result := validate('bbbababababbaaabaabbbaaa')): | |
| part1 += 1 | |
| print('bbbababababbaaabaabbbaaa:', result) | |
| if (result := validate('bbabaaabababaabababbbbaa')): | |
| part1 += 1 | |
| print('bbabaaabababaabababbbbaa:', result) | |
| if (result := validate('ababbbbabbbaabbaabbaabbaabbaaababaaaaaaa')): | |
| part1 += 1 | |
| print('ababbbbabbbaabbaabbaabbaabbaaababaaaaaaa:', result) | |
| if (result := validate('aabbabbbbbaabbbbaaabbbbbaaabbabbabbbaaaaabbaaababaaaaabb')): | |
| part1 += 1 | |
| print('aabbabbbbbaabbbbaaabbbbbaaabbabbabbbaaaaabbaaababaaaaabb:', result) | |
| if (result := validate('aaaaababbabbbaabbaababbbbabaaaaabbabbaabbbabbaab')): | |
| part1 += 1 | |
| print('aaaaababbabbbaabbaababbbbabaaaaabbabbaabbbabbaab:', result) | |
| if (result := validate('babbbbbaababaaaaaaababbaabaaaaaabbababaa')): | |
| part1 += 1 | |
| print('babbbbbaababaaaaaaababbaabaaaaaabbababaa:', result) | |
| if (result := validate('babaabbababbbbbaaabbbabb')): | |
| part1 += 1 | |
| print('babaabbababbbbbaaabbbabb:', result) | |
| if (result := validate('aabbaabbbbbaabababaaaaba')): | |
| part1 += 1 | |
| print('aabbaabbbbbaabababaaaaba:', result) | |
| if (result := validate('aaabbababbbbababaababbab')): | |
| part1 += 1 | |
| print('aaabbababbbbababaababbab:', result) | |
| if (result := validate('abbabbbabbbaaabbaaabaababbabbbaabbaabaaababbbaaa')): | |
| part1 += 1 | |
| print('abbabbbabbbaaabbaaabaababbabbbaabbaabaaababbbaaa:', result) | |
| if (result := validate('aaababbaabbbabaaabababbbbbbbabbbbabaabbb')): | |
| part1 += 1 | |
| print('aaababbaabbbabaaabababbbbbbbabbbbabaabbb:', result) | |
| if (result := validate('abbaaaabaaaaaaabbabaabaa')): | |
| part1 += 1 | |
| print('abbaaaabaaaaaaabbabaabaa:', result) | |
| if (result := validate('aaaabaababaaababbabbabab')): | |
| part1 += 1 | |
| print('aaaabaababaaababbabbabab:', result) | |
| if (result := validate('aabaabaaaaaaaaabbbbbbaabbaabbbbaabaaaabbaabaabbbbaababbb')): | |
| part1 += 1 | |
| print('aabaabaaaaaaaaabbbbbbaabbaabbbbaabaaaabbaabaabbbbaababbb:', result) | |
| if (result := validate('abaababbbbbaaabbbabbaaabbbbbaaab')): | |
| part1 += 1 | |
| print('abaababbbbbaaabbbabbaaabbbbbaaab:', result) | |
| if (result := validate('ababaabaabaaabababaaabbbabaaaabbaaaaaaabaaaababbabbbaaaaaaababbb')): | |
| part1 += 1 | |
| print('ababaabaabaaabababaaabbbabaaaabbaaaaaaabaaaababbabbbaaaaaaababbb:', result) | |
| if (result := validate('bbbbbabbbbbaaabbabbbbaaa')): | |
| part1 += 1 | |
| print('bbbbbabbbbbaaabbabbbbaaa:', result) | |
| if (result := validate('abbaabaabaababaaabbaaaabbbababbabbabbbab')): | |
| part1 += 1 | |
| print('abbaabaabaababaaabbaaaabbbababbabbabbbab:', result) | |
| if (result := validate('babbbaababbbaabaaaabbbbabbbbbaabaabbabaa')): | |
| part1 += 1 | |
| print('babbbaababbbaabaaaabbbbabbbbbaabaabbabaa:', result) | |
| if (result := validate('bbabaabaaaaabbaabaaabaaa')): | |
| part1 += 1 | |
| print('bbabaabaaaaabbaabaaabaaa:', result) | |
| if (result := validate('aabaaabbbbbbbbabaabbbabb')): | |
| part1 += 1 | |
| print('aabaaabbbbbbbbabaabbbabb:', result) | |
| if (result := validate('abaababbabbbaabaabbbaaabbabbbbaa')): | |
| part1 += 1 | |
| print('abaababbabbbaabaabbbaaabbabbbbaa:', result) | |
| if (result := validate('babbbaabaaaabbbbbaaabbbb')): | |
| part1 += 1 | |
| print('babbbaabaaaabbbbbaaabbbb:', result) | |
| if (result := validate('bababaaaababbababbbaabbaabaaaabb')): | |
| part1 += 1 | |
| print('bababaaaababbababbbaabbaabaaaabb:', result) | |
| if (result := validate('ababaababbbbaaabaaaaabaababbaabbaaaabbabbbabbbbaabaaaababaaaabbb')): | |
| part1 += 1 | |
| print('ababaababbbbaaabaaaaabaababbaabbaaaabbabbbabbbbaabaaaababaaaabbb:', result) | |
| if (result := validate('abbaaabbbaaaababaaaabbababbaaabaaabbbaabbababaab')): | |
| part1 += 1 | |
| print('abbaaabbbaaaababaaaabbababbaaabaaabbbaabbababaab:', result) | |
| if (result := validate('baabbbbaababaabbaabbabbbaaabbabaaabaaaaabbbbaaab')): | |
| part1 += 1 | |
| print('baabbbbaababaabbaabbabbbaaabbabaaabaaaaabbbbaaab:', result) | |
| if (result := validate('bbaabbbabbaaaabbaabbbbbabbabbbabbbaaabab')): | |
| part1 += 1 | |
| print('bbaabbbabbaaaabbaabbbbbabbabbbabbbaaabab:', result) | |
| if (result := validate('babababbbbabaaaabaaababababbaabb')): | |
| part1 += 1 | |
| print('babababbbbabaaaabaaababababbaabb:', result) | |
| if (result := validate('baaabbbabbbbabababbaaaba')): | |
| part1 += 1 | |
| print('baaabbbabbbbabababbaaaba:', result) | |
| if (result := validate('baaabbabbbabbbbbaabbabaa')): | |
| part1 += 1 | |
| print('baaabbabbbabbbbbaabbabaa:', result) | |
| if (result := validate('bbaabbbababbbabbbabaaaaabbabaaba')): | |
| part1 += 1 | |
| print('bbaabbbababbbabbbabaaaaabbabaaba:', result) | |
| if (result := validate('bbaabbaaaabbbbbabbbbabbbaaaabbab')): | |
| part1 += 1 | |
| print('bbaabbaaaabbbbbabbbbabbbaaaabbab:', result) | |
| if (result := validate('baaabababbbaaababaabbabb')): | |
| part1 += 1 | |
| print('baaabababbbaaababaabbabb:', result) | |
| if (result := validate('aaaaababbbabbbbabaabaabaabbababb')): | |
| part1 += 1 | |
| print('aaaaababbbabbbbabaabaabaabbababb:', result) | |
| if (result := validate('babaabbabbabaaaaababaabaaaaaaaaa')): | |
| part1 += 1 | |
| print('babaabbabbabaaaaababaabaaaaaaaaa:', result) | |
| if (result := validate('abbbaabaaaaabaababbbabbabbbaaabbaaabaabb')): | |
| part1 += 1 | |
| print('abbbaabaaaaabaababbbabbabbbaaabbaaabaabb:', result) | |
| if (result := validate('bbabbbaaaaabaababababbbbbbbbaabbaabababb')): | |
| part1 += 1 | |
| print('bbabbbaaaaabaababababbbbbbbbaabbaabababb:', result) | |
| if (result := validate('abbabbbaabbababbabaabbba')): | |
| part1 += 1 | |
| print('abbabbbaabbababbabaabbba:', result) | |
| if (result := validate('aaaaababbbaabbbaabbababaaabaababaaababbb')): | |
| part1 += 1 | |
| print('aaaaababbbaabbbaabbababaaabaababaaababbb:', result) | |
| if (result := validate('aaabaaabbabbaaababbabbaabbabbaab')): | |
| part1 += 1 | |
| print('aaabaaabbabbaaababbabbaabbabbaab:', result) | |
| if (result := validate('aaabababbaabaaabbaabbaab')): | |
| part1 += 1 | |
| print('aaabababbaabaaabbaabbaab:', result) | |
| if (result := validate('babbbbaaaaaaaabbabababaabbabbabbaaababaababbaababbaaaaaa')): | |
| part1 += 1 | |
| print('babbbbaaaaaaaabbabababaabbabbabbaaababaababbaababbaaaaaa:', result) | |
| if (result := validate('babaaaabaababbaabaabbababbbbabababababbaaaaabbbabaaabbaa')): | |
| part1 += 1 | |
| print('babaaaabaababbaabaabbababbbbabababababbaaaaabbbabaaabbaa:', result) | |
| if (result := validate('aabbbbabbabbbaaabbbaababbbaababbabaaabbbbbbbbaaabababaabbbbbbaabbbbaaaba')): | |
| part1 += 1 | |
| print('aabbbbabbabbbaaabbbaababbbaababbabaaabbbbbbbbaaabababaabbbbbbaabbbbaaaba:', result) | |
| if (result := validate('aaabaabaaaaaaaababaababbbaaabaaababaabaa')): | |
| part1 += 1 | |
| print('aaabaabaaaaaaaababaababbbaaabaaababaabaa:', result) | |
| if (result := validate('abbbabbaabbbabaaaabababb')): | |
| part1 += 1 | |
| print('abbbabbaabbbabaaaabababb:', result) | |
| if (result := validate('abababaaabbbabaabbabababaaaaabbbbbabbbbbbbbabaabaababaabbabababaabbbabab')): | |
| part1 += 1 | |
| print('abababaaabbbabaabbabababaaaaabbbbbabbbbbbbbabaabaababaabbabababaabbbabab:', result) | |
| if (result := validate('bbbbbbababbbabaaabbaabba')): | |
| part1 += 1 | |
| print('bbbbbbababbbabaaabbaabba:', result) | |
| if (result := validate('aabaaabbbbaaaaaaaabbabaa')): | |
| part1 += 1 | |
| print('aabaaabbbbaaaaaaaabbabaa:', result) | |
| if (result := validate('aabaaababbbbabababababbbaabaabbabaababab')): | |
| part1 += 1 | |
| print('aabaaababbbbabababababbbaabaabbabaababab:', result) | |
| if (result := validate('ababbbaaaaababbabababbabaababaabbbbbaaaa')): | |
| part1 += 1 | |
| print('ababbbaaaaababbabababbabaababaabbbbbaaaa:', result) | |
| if (result := validate('aabbaaabbaaaabbbaaaaabaaaaaaaaaa')): | |
| part1 += 1 | |
| print('aabbaaabbaaaabbbaaaaabaaaaaaaaaa:', result) | |
| if (result := validate('bababbababbaaaababbabbbbbbaababbbbaabaaa')): | |
| part1 += 1 | |
| print('bababbababbaaaababbabbbbbbaababbbbaabaaa:', result) | |
| if (result := validate('abaabaaaaabaaabbabbbabab')): | |
| part1 += 1 | |
| print('abaabaaaaabaaabbabbbabab:', result) | |
| if (result := validate('bbbababbaabbaababbaaaaaabbaaaaab')): | |
| part1 += 1 | |
| print('bbbababbaabbaababbaaaaaabbaaaaab:', result) | |
| if (result := validate('aabbbaabbbbbaaaaaaaabbabbaabaabbbbabbbbabaaaaaaaaaabbabbbaaaabbb')): | |
| part1 += 1 | |
| print('aabbbaabbbbbaaaaaaaabbabbaabaabbbbabbbbabaaaaaaaaaabbabbbaaaabbb:', result) | |
| if (result := validate('babababbabbababaaaabbbaabaaabaaaaaabaabb')): | |
| part1 += 1 | |
| print('babababbabbababaaaabbbaabaaabaaaaaabaabb:', result) | |
| if (result := validate('baabbaaaaabbaaabbbaabbab')): | |
| part1 += 1 | |
| print('baabbaaaaabbaaabbbaabbab:', result) | |
| if (result := validate('aaaaabbbbabbbaabbaaaaaab')): | |
| part1 += 1 | |
| print('aaaaabbbbabbbaabbaaaaaab:', result) | |
| if (result := validate('aabbbbaabbaabbbbabbbbaab')): | |
| part1 += 1 | |
| print('aabbbbaabbaabbbbabbbbaab:', result) | |
| if (result := validate('bbbbabaababbbabbbbabaabbbaabbababbaabbaaaabaaaaa')): | |
| part1 += 1 | |
| print('bbbbabaababbbabbbbabaabbbaabbababbaabbaaaabaaaaa:', result) | |
| if (result := validate('ababababbbbabbbabbbabaaabbaababaaaaabbba')): | |
| part1 += 1 | |
| print('ababababbbbabbbabbbabaaabbaababaaaaabbba:', result) | |
| if (result := validate('aababaaabaaababbabbbbbbabbabbaabbaaabaaa')): | |
| part1 += 1 | |
| print('aababaaabaaababbabbbbbbabbabbaabbaaabaaa:', result) | |
| if (result := validate('ababaabbbaabbababbbaaabbbaababbbabaaaaba')): | |
| part1 += 1 | |
| print('ababaabbbaabbababbbaaabbbaababbbabaaaaba:', result) | |
| if (result := validate('abababbaaababababaaabbbabbbaaaab')): | |
| part1 += 1 | |
| print('abababbaaababababaaabbbabbbaaaab:', result) | |
| if (result := validate('aabaaabbaaaaaaabbabbabba')): | |
| part1 += 1 | |
| print('aabaaabbaaaaaaabbabbabba:', result) | |
| if (result := validate('baaabbbababbbabbaaababbb')): | |
| part1 += 1 | |
| print('baaabbbababbbabbaaababbb:', result) | |
| if (result := validate('babbaaababbbabaabbbbbbba')): | |
| part1 += 1 | |
| print('babbaaababbbabaabbbbbbba:', result) | |
| if (result := validate('bbabaaabbbabbbbbaabaabab')): | |
| part1 += 1 | |
| print('bbabaaabbbabbbbbaabaabab:', result) | |
| if (result := validate('abababaabaabbababbbaabbb')): | |
| part1 += 1 | |
| print('abababaabaabbababbbaabbb:', result) | |
| if (result := validate('aaabbabbaabbaaabababbbabaababaabaaaaabba')): | |
| part1 += 1 | |
| print('aaabbabbaabbaaabababbbabaababaabaaaaabba:', result) | |
| if (result := validate('bbababbaabababbbbabbaaba')): | |
| part1 += 1 | |
| print('bbababbaabababbbbabbaaba:', result) | |
| if (result := validate('baaaabbabaabbaaabbbaabaaababbaaaaabbbaaa')): | |
| part1 += 1 | |
| print('baaaabbabaabbaaabbbaabaaababbaaaaabbbaaa:', result) | |
| if (result := validate('aaaabbbaaabbbbbabaaabbaaaaababbabababaaaabaabbabbbbaaaabaababaab')): | |
| part1 += 1 | |
| print('aaaabbbaaabbbbbabaaabbaaaaababbabababaaaabaabbabbbbaaaabaababaab:', result) | |
| if (result := validate('bbabbbbbababaabababbbbbaabbbaabb')): | |
| part1 += 1 | |
| print('bbabbbbbababaabababbbbbaabbbaabb:', result) | |
| if (result := validate('abaabbababbabbaabbaabbbabbbaaaabbbbbaaab')): | |
| part1 += 1 | |
| print('abaabbababbabbaabbaabbbabbbaaaabbbbbaaab:', result) | |
| if (result := validate('aabbaabbabbbbabbbbabbbaaabbbabbbabbbbabbaaaaabaa')): | |
| part1 += 1 | |
| print('aabbaabbabbbbabbbbabbbaaabbbabbbabbbbabbaaaaabaa:', result) | |
| if (result := validate('bbabaaaabaaabbbabbbabababaabbbbaabaaaaabbaababbaabbaaaba')): | |
| part1 += 1 | |
| print('bbabaaaabaaabbbabbbabababaabbbbaabaaaaabbaababbaabbaaaba:', result) | |
| if (result := validate('abbaababbbbbaaaabbbbaabbbbabbbabbaaabaabbabaababbbbaaaaa')): | |
| part1 += 1 | |
| print('abbaababbbbbaaaabbbbaabbbbabbbabbaaabaabbabaababbbbaaaaa:', result) | |
| if (result := validate('aaaabababbaabbaabbbbbbabbabbaabb')): | |
| part1 += 1 | |
| print('aaaabababbaabbaabbbbbbabbabbaabb:', result) | |
| if (result := validate('baaaaabaaaaaaaababaababbaabababaabbbbaaa')): | |
| part1 += 1 | |
| print('baaaaabaaaaaaaababaababbaabababaabbbbaaa:', result) | |
| if (result := validate('abbabababbaaaaaabbaaabba')): | |
| part1 += 1 | |
| print('abbabababbaaaaaabbaaabba:', result) | |
| if (result := validate('aaaabbbaabaabaababaabbabbaabaaaabababaaabaababbaaaaabababbaabaababaabaab')): | |
| part1 += 1 | |
| print('aaaabbbaabaabaababaabbabbaabaaaabababaaabaababbaaaaabababbaabaababaabaab:', result) | |
| if (result := validate('babbbabbbbbbbabbbbbbbaaa')): | |
| part1 += 1 | |
| print('babbbabbbbbbbabbbbbbbaaa:', result) | |
| if (result := validate('abaaababbbabbabaabbbbabbbaaababaaaaabaaaaaabaabaabbbabbababaaabbbaabbbbaabbbabbb')): | |
| part1 += 1 | |
| print('abaaababbbabbabaabbbbabbbaaababaaaaabaaaaaabaabaabbbabbababaaabbbaabbbbaabbbabbb:', result) | |
| if (result := validate('bbabaabababbbaabbaabbababbaabbbbabaaaaaaaaabbaabbabbbbbb')): | |
| part1 += 1 | |
| print('bbabaabababbbaabbaabbababbaabbbbabaaaaaaaaabbaabbabbbbbb:', result) | |
| if (result := validate('aabbbbbbaabbabbbbbbaaabababbabaaaaabaaaa')): | |
| part1 += 1 | |
| print('aabbbbbbaabbabbbbbbaaabababbabaaaaabaaaa:', result) | |
| if (result := validate('bbbabbbaaababbaabaaababbbaaabaabbaaabaab')): | |
| part1 += 1 | |
| print('bbbabbbaaababbaabaaababbbaaabaabbaaabaab:', result) | |
| if (result := validate('baabbaaaaaabbbbabbabaabaaaaabbbbbbbbbaba')): | |
| part1 += 1 | |
| print('baabbaaaaaabbbbabbabaabaaaaabbbbbbbbbaba:', result) | |
| if (result := validate('abbabaabbababbabbbbabaab')): | |
| part1 += 1 | |
| print('abbabaabbababbabbbbabaab:', result) | |
| if (result := validate('abbabaabaabbbbbaaabaaabbbaabaaaa')): | |
| part1 += 1 | |
| print('abbabaabaabbbbbaaabaaabbbaabaaaa:', result) | |
| if (result := validate('aaaaababbaabaaabaabbabbbbbaabaabbabbababaababbab')): | |
| part1 += 1 | |
| print('aaaaababbaabaaabaabbabbbbbaabaabbabbababaababbab:', result) | |
| if (result := validate('aaaaabbbabbabbbabaaaaabb')): | |
| part1 += 1 | |
| print('aaaaabbbabbabbbabaaaaabb:', result) | |
| if (result := validate('aabbabbbbabbbaabaabbbbbbbbabbaaabaaaabbbbbabbaabbbaaabbbababbbba')): | |
| part1 += 1 | |
| print('aabbabbbbabbbaabaabbbbbbbbabbaaabaaaabbbbbabbaabbbaaabbbababbbba:', result) | |
| if (result := validate('bbbbababbbaaababaababbab')): | |
| part1 += 1 | |
| print('bbbbababbbaaababaababbab:', result) | |
| if (result := validate('abbbaabababaabbaaababbba')): | |
| part1 += 1 | |
| print('abbbaabababaabbaaababbba:', result) | |
| if (result := validate('bbbbbbababbbaabaabbbbabbbabbbaba')): | |
| part1 += 1 | |
| print('bbbbbbababbbaabaabbbbabbbabbbaba:', result) | |
| if (result := validate('bbabaaaabbaabbbbabbbaabb')): | |
| part1 += 1 | |
| print('bbabaaaabbaabbbbabbbaabb:', result) | |
| if (result := validate('baaaabbababbaababbbbaaaabbaaabaabbaaaabababaaabaaabababb')): | |
| part1 += 1 | |
| print('baaaabbababbaababbbbaaaabbaaabaabbaaaabababaaabaaabababb:', result) | |
| if (result := validate('bbabbaaaaabaaabbbbabbaba')): | |
| part1 += 1 | |
| print('bbabbaaaaabaaabbbbabbaba:', result) | |
| if (result := validate('bbaabbbbabaababbbbaaaaba')): | |
| part1 += 1 | |
| print('bbaabbbbabaababbbbaaaaba:', result) | |
| if (result := validate('babababbabaababbabbbabab')): | |
| part1 += 1 | |
| print('babababbabaababbabbbabab:', result) | |
| if (result := validate('bbabaaaabbbbbaabbaababaabaaaaaabbabaababaababbbaababbaaa')): | |
| part1 += 1 | |
| print('bbabaaaabbbbbaabbaababaabaaaaaabbabaababaababbbaababbaaa:', result) | |
| if (result := validate('aaababbaaabababaabababbaabbabaaa')): | |
| part1 += 1 | |
| print('aaababbaaabababaabababbaabbabaaa:', result) | |
| if (result := validate('bbaabaabaabaabaaabbbaaabbbaabaabbbbbbbbaabbbaabbabaaaabb')): | |
| part1 += 1 | |
| print('bbaabaabaabaabaaabbbaaabbbaabaabbbbbbbbaabbbaabbabaaaabb:', result) | |
| if (result := validate('baaaaabaaaaababababbabbbaabbbbaabbbbabbbbbaaababbaaabaab')): | |
| part1 += 1 | |
| print('baaaaabaaaaababababbabbbaabbbbaabbbbabbbbbaaababbaaabaab:', result) | |
| if (result := validate('baaaabbbababaabababababa')): | |
| part1 += 1 | |
| print('baaaabbbababaabababababa:', result) | |
| if (result := validate('abbbbaaababbbaaabbabaabbaaabbabaabbabaaabbbbabbaabaabbababbbbbaabaabaababbaaabaababbbabb')): | |
| part1 += 1 | |
| print('abbbbaaababbbaaabbabaabbaaabbabaabbabaaabbbbabbaabaabbababbbbbaabaabaababbaaabaababbbabb:', result) | |
| if (result := validate('babbbbbaabbababaabababaaaaaaaabbaabaaabbababbbbaabaabbbaababbaba')): | |
| part1 += 1 | |
| print('babbbbbaabbababaabababaaaaaaaabbaabaaabbababbbbaabaabbbaababbaba:', result) | |
| if (result := validate('aaaaaabbbabbbbbaaabababaabaaabba')): | |
| part1 += 1 | |
| print('aaaaaabbbabbbbbaaabababaabaaabba:', result) | |
| if (result := validate('aabaaabbaaabbbbababbbaaa')): | |
| part1 += 1 | |
| print('aabaaabbaaabbbbababbbaaa:', result) | |
| if (result := validate('abaabbbbaabbbbabbbbbbaba')): | |
| part1 += 1 | |
| print('abaabbbbaabbbbabbbbbbaba:', result) | |
| if (result := validate('abbbaaabaaaaababbbbbbbabbbbabaabaaaabaaa')): | |
| part1 += 1 | |
| print('abbbaaabaaaaababbbbbbbabbbbabaabaaaabaaa:', result) | |
| if (result := validate('bbbaaabaababaaaaabaaabaa')): | |
| part1 += 1 | |
| print('bbbaaabaababaaaaabaaabaa:', result) | |
| if (result := validate('bbaaabbbbaabbbabbbbbabbaabaaaaba')): | |
| part1 += 1 | |
| print('bbaaabbbbaabbbabbbbbabbaabaaaaba:', result) | |
| if (result := validate('abababbabbabbbbbabbaaaba')): | |
| part1 += 1 | |
| print('abababbabbabbbbbabbaaaba:', result) | |
| if (result := validate('abbaabababbaaabbbabbaaaa')): | |
| part1 += 1 | |
| print('abbaabababbaaabbbabbaaaa:', result) | |
| if (result := validate('abaabaaaabaaabbbaababaab')): | |
| part1 += 1 | |
| print('abaabaaaabaaabbbaababaab:', result) | |
| if (result := validate('baaabbbabbabbabbaabaaaab')): | |
| part1 += 1 | |
| print('baaabbbabbabbabbaabaaaab:', result) | |
| if (result := validate('bbaabbabaababbbbbabaabbbababaaabaabbbbabaababaaabaabbabbababaaab')): | |
| part1 += 1 | |
| print('bbaabbabaababbbbbabaabbbababaaabaabbbbabaababaaabaabbabbababaaab:', result) | |
| if (result := validate('bababbbbbbababbabbbabbaa')): | |
| part1 += 1 | |
| print('bababbbbbbababbabbbabbaa:', result) | |
| if (result := validate('aabaabaaaaaaabaaaabaabbb')): | |
| part1 += 1 | |
| print('aabaabaaaaaaabaaaabaabbb:', result) | |
| if (result := validate('abbbaaababaabaaaabbabbbaabbbaaaabaabaaaa')): | |
| part1 += 1 | |
| print('abbbaaababaabaaaabbabbbaabbbaaaabaabaaaa:', result) | |
| if (result := validate('aaaaaaaaaaaabaabbaabbbabababbaabaaabbabb')): | |
| part1 += 1 | |
| print('aaaaaaaaaaaabaabbaabbbabababbaabaaabbabb:', result) | |
| if (result := validate('bbbabbbbbabaabbaabbbbaab')): | |
| part1 += 1 | |
| print('bbbabbbbbabaabbaabbbbaab:', result) | |
| if (result := validate('aabbabbbbababbabbaabaaba')): | |
| part1 += 1 | |
| print('aabbabbbbababbabbaabaaba:', result) | |
| if (result := validate('bbabbbbbbbabaabbaaaabbab')): | |
| part1 += 1 | |
| print('bbabbbbbbbabaabbaaaabbab:', result) | |
| if (result := validate('aaaaababaabbbbabbabbaaba')): | |
| part1 += 1 | |
| print('aaaaababaabbbbabbabbaaba:', result) | |
| if (result := validate('bbbabbbaaabaaabbaaaababaaaabaaaaaabababb')): | |
| part1 += 1 | |
| print('bbbabbbaaabaaabbaaaababaaaabaaaaaabababb:', result) | |
| if (result := validate('bbbbabababaabaabbabaabbabbbabbabbabbbbbb')): | |
| part1 += 1 | |
| print('bbbbabababaabaabbabaabbabbbabbabbabbbbbb:', result) | |
| if (result := validate('aababaaaaaabbbbbaabbabab')): | |
| part1 += 1 | |
| print('aababaaaaaabbbbbaabbabab:', result) | |
| if (result := validate('abbbabbabaaaaabbbaaaaaaabbabbabaaabbaabbbbaaaabbbbaababbabaaababbababbbb')): | |
| part1 += 1 | |
| print('abbbabbabaaaaabbbaaaaaaabbabbabaaabbaabbbbaaaabbbbaababbabaaababbababbbb:', result) | |
| if (result := validate('bbaabbbaaabababaaaaaababbbbababaabbababbababbaaaaaaaaaabbabaababbbaaababbbabbaaa')): | |
| part1 += 1 | |
| print('bbaabbbaaabababaaaaaababbbbababaabbababbababbaaaaaaaaaabbabaababbbaaababbbabbaaa:', result) | |
| if (result := validate('aaaaabbbaababbaababababbbabbbbbababababa')): | |
| part1 += 1 | |
| print('aaaaabbbaababbaababababbbabbbbbababababa:', result) | |
| if (result := validate('aabbbbbbabaabaaabaaaabbbaabbbaaaaaabbbbb')): | |
| part1 += 1 | |
| print('aabbbbbbabaabaaabaaaabbbaabbbaaaaaabbbbb:', result) | |
| if (result := validate('bbbbbabbbaabaaabbababbbbbbbaaabaaabaaabaaababbbbbabbabbaabbaabbb')): | |
| part1 += 1 | |
| print('bbbbbabbbaabaaabbababbbbbbbaaabaaabaaabaaababbbbbabbabbaabbaabbb:', result) | |
| if (result := validate('aabbaaaaaabbbbabaababaaaabbababbaaababbb')): | |
| part1 += 1 | |
| print('aabbaaaaaabbbbabaababaaaabbababbaaababbb:', result) | |
| if (result := validate('aabaabbbabbaabbabababaaaabbaabbbabaaabaa')): | |
| part1 += 1 | |
| print('aabaabbbabbaabbabababaaaabbaabbbabaaabaa:', result) | |
| if (result := validate('aaababbabbabaabaabababaaaaabababbbbbabbabbbbaaaa')): | |
| part1 += 1 | |
| print('aaababbabbabaabaabababaaaaabababbbbbabbabbbbaaaa:', result) | |
| if (result := validate('abbbabbaabbaabaabbabababbbbababaabbbbaaa')): | |
| part1 += 1 | |
| print('abbbabbaabbaabaabbabababbbbababaabbbbaaa:', result) | |
| if (result := validate('baaabbbaaabbabbbabbbbabaabababaabbaabaabbbbbaabb')): | |
| part1 += 1 | |
| print('baaabbbaaabbabbbabbbbabaabababaabbaabaabbbbbaabb:', result) | |
| if (result := validate('bbbabbbbabbaabaaabbbabaaaabababaaaaaaabbbbaabaaa')): | |
| part1 += 1 | |
| print('bbbabbbbabbaabaaabbbabaaaabababaaaaaaabbbbaabaaa:', result) | |
| if (result := validate('abaaabbbbbbbbabbaaaaababbababaabaabaaabbababbaaabaabbbaa')): | |
| part1 += 1 | |
| print('abaaabbbbbbbbabbaaaaababbababaabaabaaabbababbaaabaabbbaa:', result) | |
| if (result := validate('aaabababbbabaaabababaaaababbbaba')): | |
| part1 += 1 | |
| print('aaabababbbabaaabababaaaababbbaba:', result) | |
| if (result := validate('aabbaabbbaabbbaaabaaaabb')): | |
| part1 += 1 | |
| print('aabbaabbbaabbbaaabaaaabb:', result) | |
| if (result := validate('abbababaaabbaaaaaaaaaaabbbabbbaabababbababaaaaaa')): | |
| part1 += 1 | |
| print('abbababaaabbaaaaaaaaaaabbbabbbaabababbababaaaaaa:', result) | |
| if (result := validate('aaaababbbbbabbbbaaabababbbbaaabaabbababb')): | |
| part1 += 1 | |
| print('aaaababbbbbabbbbaaabababbbbaaabaabbababb:', result) | |
| if (result := validate('bbbabaaaabbbbabbabbbbababbaaabba')): | |
| part1 += 1 | |
| print('bbbabaaaabbbbabbabbbbababbaaabba:', result) | |
| if (result := validate('abaaabbbbababbababbabbaabbaaabaababbbaaa')): | |
| part1 += 1 | |
| print('abaaabbbbababbababbabbaabbaaabaababbbaaa:', result) | |
| if (result := validate('abababaaabaaabbaababbbbb')): | |
| part1 += 1 | |
| print('abababaaabaaabbaababbbbb:', result) | |
| if (result := validate('ababaaaaaabaabaababbbbbaaababaab')): | |
| part1 += 1 | |
| print('ababaaaaaabaabaababbbbbaaababaab:', result) | |
| if (result := validate('abbaabaaaaaaaabbbbabaababbaaaaaabbbabaaabbabbbbabbabbbabbbabbaba')): | |
| part1 += 1 | |
| print('abbaabaaaaaaaabbbbabaababbaaaaaabbbabaaabbabbbbabbabbbabbbabbaba:', result) | |
| if (result := validate('baabbaaaaaaabbbbababbabb')): | |
| part1 += 1 | |
| print('baabbaaaaaaabbbbababbabb:', result) | |
| if (result := validate('aababaaaabababbabaaaaabaababaabaababaabbaabbbaaababbbbaa')): | |
| part1 += 1 | |
| print('aababaaaabababbabaaaaabaababaabaababaabbaabbbaaababbbbaa:', result) | |
| if (result := validate('bbababbbababbbbaaabbbaab')): | |
| part1 += 1 | |
| print('bbababbbababbbbaaabbbaab:', result) | |
| if (result := validate('baaabbbbbbbbbabaabaabbbbababaababbaabaabaabbababaaababbaabbaabbaaababaaabbabaaabbbabaaaa')): | |
| part1 += 1 | |
| print('baaabbbbbbbbbabaabaabbbbababaababbaabaabaabbababaaababbaabbaabbaaababaaabbabaaabbbabaaaa:', result) | |
| if (result := validate('aaaaabbabbaaaaaababaaabaabaaababababbbaaaabbbaaaabbaabaaabababab')): | |
| part1 += 1 | |
| print('aaaaabbabbaaaaaababaaabaabaaababababbbaaaabbbaaaabbaabaaabababab:', result) | |
| if (result := validate('bbaabbaabbabbbaaaaaaabbbbaabaaababbbbaaababaabbbbabaabab')): | |
| part1 += 1 | |
| print('bbaabbaabbabbbaaaaaaabbbbaabaaababbbbaaababaabbbbabaabab:', result) | |
| if (result := validate('bbbbabababbabbbbaaaababaabbaabba')): | |
| part1 += 1 | |
| print('bbbbabababbabbbbaaaababaabbaabba:', result) | |
| if (result := validate('bbbaababbabababbababaabaaaabbbaaaabbbaab')): | |
| part1 += 1 | |
| print('bbbaababbabababbababaabaaaabbbaaaabbbaab:', result) | |
| if (result := validate('bbabaabbbabaaaabbabbbabbbbbbbaaaaaabaaaa')): | |
| part1 += 1 | |
| print('bbabaabbbabaaaabbabbbabbbbbbbaaaaaabaaaa:', result) | |
| if (result := validate('abbababbbabaabbaabbbbaaa')): | |
| part1 += 1 | |
| print('abbababbbabaabbaabbbbaaa:', result) | |
| if (result := validate('baabaaaaaaababbaabbbaaaaabbbaaababbabbbbabbbbbbaabbbabba')): | |
| part1 += 1 | |
| print('baabaaaaaaababbaabbbaaaaabbbaaababbabbbbabbbbbbaabbbabba:', result) | |
| if (result := validate('aabbababaaabaaaabbbaaaaaabbbbaab')): | |
| part1 += 1 | |
| print('aabbababaaabaaaabbbaaaaaabbbbaab:', result) | |
| if (result := validate('bababbbaabaabaaabaababba')): | |
| part1 += 1 | |
| print('bababbbaabaabaaabaababba:', result) | |
| if (result := validate('bbbaaabbbbbbaabaabbbbbab')): | |
| part1 += 1 | |
| print('bbbaaabbbbbbaabaabbbbbab:', result) | |
| if (result := validate('bbbbabbbbaaaaabbbbaabbab')): | |
| part1 += 1 | |
| print('bbbbabbbbaaaaabbbbaabbab:', result) | |
| if (result := validate('bbbabbbababbbabbbabbabab')): | |
| part1 += 1 | |
| print('bbbabbbababbbabbbabbabab:', result) | |
| if (result := validate('abaabaaababaabbabbbbbabbbbbbabababbbbbbb')): | |
| part1 += 1 | |
| print('abaabaaababaabbabbbbbabbbbbbabababbbbbbb:', result) | |
| if (result := validate('ababaababaabbaaabaaaabbbbabaaaabbbbbabbbaababbabaabbbabb')): | |
| part1 += 1 | |
| print('ababaababaabbaaabaaaabbbbabaaaabbbbbabbbaababbabaabbbabb:', result) | |
| if (result := validate('aaaabababaabbabababababa')): | |
| part1 += 1 | |
| print('aaaabababaabbabababababa:', result) | |
| if (result := validate('baababaabbbbbbabbaabbaab')): | |
| part1 += 1 | |
| print('baababaabbbbbbabbaabbaab:', result) | |
| if (result := validate('abababaaabbbabbaaaabaaabaaaaaaaa')): | |
| part1 += 1 | |
| print('abababaaabbbabbaaaabaaabaaaaaaaa:', result) | |
| if (result := validate('bbaabbbbaabbabbaabbbaababbbaabaaaabaaaba')): | |
| part1 += 1 | |
| print('bbaabbbbaabbabbaabbbaababbbaabaaaabaaaba:', result) | |
| if (result := validate('babababaaaabbbbbaaabbbbabbaabaaabaaaabbbababbbbaababbababbaaaaab')): | |
| part1 += 1 | |
| print('babababaaaabbbbbaaabbbbabbaabaaabaaaabbbababbbbaababbababbaaaaab:', result) | |
| if (result := validate('bbbaabaaabbabbaabbaabaaa')): | |
| part1 += 1 | |
| print('bbbaabaaabbabbaabbaabaaa:', result) | |
| if (result := validate('babbaabbbabaabababbaabaabaabaabbaabbabbbaaaabaabbbbbbbbbaaabaaababaaaaaabbbbaaaabbbabaaa')): | |
| part1 += 1 | |
| print('babbaabbbabaabababbaabaabaabaabbaabbabbbaaaabaabbbbbbbbbaaabaaababaaaaaabbbbaaaabbbabaaa:', result) | |
| if (result := validate('babbbbbaaabaaabbaabaaaab')): | |
| part1 += 1 | |
| print('babbbbbaaabaaabbaabaaaab:', result) | |
| if (result := validate('bababbababaaabbaabbaabbb')): | |
| part1 += 1 | |
| print('bababbababaaabbaabbaabbb:', result) | |
| if (result := validate('bbaabbbbaaaaabaaabbabbbbbbbbbaaa')): | |
| part1 += 1 | |
| print('bbaabbbbaaaaabaaabbabbbbbbbbbaaa:', result) | |
| if (result := validate('bababbabbbabbbbbabbbbabbabababbaaabbaaabbbaaabbabaaaababbbbaaaabbbabbbab')): | |
| part1 += 1 | |
| print('bababbabbbabbbbbabbbbabbabababbaaabbaaabbbaaabbabaaaababbbbaaaabbbabbbab:', result) | |
| if (result := validate('bbaabaabaaababaabbbbbbbb')): | |
| part1 += 1 | |
| print('bbaabaabaaababaabbbbbbbb:', result) | |
| if (result := validate('bbaabbaaaabbaabaabbabbaabaaabbbaaaabbabbbabbbaba')): | |
| part1 += 1 | |
| print('bbaabbaaaabbaabaabbabbaabaaabbbaaaabbabbbabbbaba:', result) | |
| if (result := validate('bbbababbbbbbaababbbaabbbbaababba')): | |
| part1 += 1 | |
| print('bbbababbbbbbaababbbaabbbbaababba:', result) | |
| if (result := validate('bababbababababbabbaaabab')): | |
| part1 += 1 | |
| print('bababbababababbabbaaabab:', result) | |
| if (result := validate('aaabababbbaabbbbbbabbbba')): | |
| part1 += 1 | |
| print('aaabababbbaabbbbbbabbbba:', result) | |
| if (result := validate('bbbabbbaaaababaaabbbbabbbbabbabbabbbbaab')): | |
| part1 += 1 | |
| print('bbbabbbaaaababaaabbbbabbbbabbabbabbbbaab:', result) | |
| if (result := validate('aaabababababaaaaaabaaaab')): | |
| part1 += 1 | |
| print('aaabababababaaaaaabaaaab:', result) | |
| if (result := validate('abbbaaabbbbbbaabaaaaabba')): | |
| part1 += 1 | |
| print('abbbaaabbbbbbaabaaaaabba:', result) | |
| if (result := validate('abbaaabbbaababaabaabbaab')): | |
| part1 += 1 | |
| print('abbaaabbbaababaabaabbaab:', result) | |
| if (result := validate('aabaabaaabbaaaabbaababaaaabaaabbabbabaaa')): | |
| part1 += 1 | |
| print('aabaabaaabbaaaabbaababaaaabaaabbabbabaaa:', result) | |
| if (result := validate('abbabaabbbbbbaabbbbbabaaabbbabbbabbaaaaa')): | |
| part1 += 1 | |
| print('abbabaabbbbbbaabbbbbabaaabbbabbbabbaaaaa:', result) | |
| if (result := validate('aaaaababaaaaaaabbbaababbbbaabaabaaaaaabbaabaaaabbaabbabb')): | |
| part1 += 1 | |
| print('aaaaababaaaaaaabbbaababbbbaabaabaaaaaabbaabaaaabbaabbabb:', result) | |
| if (result := validate('abbbabbaaaabbabaaaabaabb')): | |
| part1 += 1 | |
| print('abbbabbaaaabbabaaaabaabb:', result) | |
| if (result := validate('bbabbabbbbbbbbaaabaaabbbbabaaaaa')): | |
| part1 += 1 | |
| print('bbabbabbbbbbbbaaabaaabbbbabaaaaa:', result) | |
| if (result := validate('aaaaabbbabaabbbbbbbaaaabbabbbbbbbabbaababbbbabba')): | |
| part1 += 1 | |
| print('aaaaabbbabaabbbbbbbaaaabbabbbbbbbabbaababbbbabba:', result) | |
| if (result := validate('babbbaabbabbbbbabbabbaab')): | |
| part1 += 1 | |
| print('babbbaabbabbbbbabbabbaab:', result) | |
| if (result := validate('abaaaaaabbbaabbaaaabaabaaaabbbbabbbbbbaabbababaaabbbaabbbbaabaaabaababaaababbbab')): | |
| part1 += 1 | |
| print('abaaaaaabbbaabbaaaabaabaaaabbbbabbbbbbaabbababaaabbbaabbbbaabaaabaababaaababbbab:', result) | |
| if (result := validate('aabaaababbaabbbbabbaabbaabbaabbb')): | |
| part1 += 1 | |
| print('aabaaababbaabbbbabbaabbaabbaabbb:', result) | |
| if (result := validate('abbaaaabaaaaaabbaabbbbbbabababbaabbbbababbaabbabbaabaaba')): | |
| part1 += 1 | |
| print('abbaaaabaaaaaabbaabbbbbbabababbaabbbbababbaabbabbaabaaba:', result) | |
| if (result := validate('baababaabaaaaababbaaaaba')): | |
| part1 += 1 | |
| print('baababaabaaaaababbaaaaba:', result) | |
| if (result := validate('abbabbaabaaababaabbbbbbaabbabababbabaaabaaaabbab')): | |
| part1 += 1 | |
| print('abbabbaabaaababaabbbbbbaabbabababbabaaabaaaabbab:', result) | |
| if (result := validate('abaaaaaaabbabababaaaaabbaaaaaaabaaababbbbbaaaaaababaaaabbabbbaaabaaabbabbaaaabbbabbbbbbb')): | |
| part1 += 1 | |
| print('abaaaaaaabbabababaaaaabbaaaaaaabaaababbbbbaaaaaababaaaabbabbbaaabaaabbabbaaaabbbabbbbbbb:', result) | |
| if (result := validate('bbbababbbaaababaabbaabba')): | |
| part1 += 1 | |
| print('bbbababbbaaababaabbaabba:', result) | |
| if (result := validate('abababbbbbabaaaaaaabbaab')): | |
| part1 += 1 | |
| print('abababbbbbabaaaaaaabbaab:', result) | |
| if (result := validate('baaabababbbaaabaaabaaabbababbaba')): | |
| part1 += 1 | |
| print('baaabababbbaaabaaabaaabbababbaba:', result) | |
| if (result := validate('abaaabbabaabbbbaabbbaabbabbaaabbababbaababbbbbbaabaaabababbabaab')): | |
| part1 += 1 | |
| print('abaaabbabaabbbbaabbbaabbabbaaabbababbaababbbbbbaabaaabababbabaab:', result) | |
| if (result := validate('bbaaaaaaaabbaababaabaaaa')): | |
| part1 += 1 | |
| print('bbaaaaaaaabbaababaabaaaa:', result) | |
| if (result := validate('bbbbbbababaaabbaabbbabaaaaaabbaaaaaaabaabbbbabba')): | |
| part1 += 1 | |
| print('bbbbbbababaaabbaabbbabaaaaaabbaaaaaaabaabbbbabba:', result) | |
| if (result := validate('bbbbbbaaabbababababbbbbababbbaabababaaab')): | |
| part1 += 1 | |
| print('bbbbbbaaabbababababbbbbababbbaabababaaab:', result) | |
| if (result := validate('baaabbabbaaaaababababbbbabbababaabbaaaaaababaaabaabbababaaabbababbababab')): | |
| part1 += 1 | |
| print('baaabbabbaaaaababababbbbabbababaabbaaaaaababaaabaabbababaaabbababbababab:', result) | |
| if (result := validate('babaaabbbaaabbaabbbabbbbbaabbaabaababbab')): | |
| part1 += 1 | |
| print('babaaabbbaaabbaabbbabbbbbaabbaabaababbab:', result) | |
| if (result := validate('bbaababbaaaabababbaaabbb')): | |
| part1 += 1 | |
| print('bbaababbaaaabababbaaabbb:', result) | |
| if (result := validate('aaaabbbbbaabaaababaaaaaa')): | |
| part1 += 1 | |
| print('aaaabbbbbaabaaababaaaaaa:', result) | |
| if (result := validate('abbbabaaaabaaababbaaaaaabbbbbbabbaabaaababbbbaabaabaaaaaaabaaaab')): | |
| part1 += 1 | |
| print('abbbabaaaabaaababbaaaaaabbbbbbabbaabaaababbbbaabaabaaaaaaabaaaab:', result) | |
| if (result := validate('aabbbbbbaaabbbaaababbaba')): | |
| part1 += 1 | |
| print('aabbbbbbaaabbbaaababbaba:', result) | |
| if (result := validate('abbbbabbabbabbbbaaaabbbbaabbbaba')): | |
| part1 += 1 | |
| print('abbbbabbabbabbbbaaaabbbbaabbbaba:', result) | |
| if (result := validate('bbbbabaaaaaaaabbbbaaabab')): | |
| part1 += 1 | |
| print('bbbbabaaaaaaaabbbbaaabab:', result) | |
| if (result := validate('bbbaaabababbbaabbabbabbbabaabbba')): | |
| part1 += 1 | |
| print('bbbaaabababbbaabbabbabbbabaabbba:', result) | |
| if (result := validate('babaababbabbbaabbabbbbbabbaabbaabbbbbabaabbbaabababaaabb')): | |
| part1 += 1 | |
| print('babaababbabbbaabbabbbbbabbaabbaabbbbbabaabbbaabababaaabb:', result) | |
| if (result := validate('bbababbaabbababbaabaabbb')): | |
| part1 += 1 | |
| print('bbababbaabbababbaabaabbb:', result) | |
| if (result := validate('bbaabbaaaababaaababaabbaabbbabaabaabbbbbaaabbaba')): | |
| part1 += 1 | |
| print('bbaabbaaaababaaababaabbaabbbabaabaabbbbbaaabbaba:', result) | |
| if (result := validate('abaabbbbbaababaabaaaabab')): | |
| part1 += 1 | |
| print('abaabbbbbaababaabaaaabab:', result) | |
| if (result := validate('bbabbaaaaabbaababbaababa')): | |
| part1 += 1 | |
| print('bbabbaaaaabbaababbaababa:', result) | |
| if (result := validate('bababbbaabbabbababbbbaababababbaababbbbaaaabbbba')): | |
| part1 += 1 | |
| print('bababbbaabbabbababbbbaababababbaababbbbaaaabbbba:', result) | |
| if (result := validate('abababbbbaaabababaaaabbabbaaabaa')): | |
| part1 += 1 | |
| print('abababbbbaaabababaaaabbabbaaabaa:', result) | |
| if (result := validate('aabbaababaabbababbaabbbbaabbabbabaabbabbbbaabbab')): | |
| part1 += 1 | |
| print('aabbaababaabbababbaabbbbaabbabbabaabbabbbbaabbab:', result) | |
| if (result := validate('aaaaabaaabaaabbbaababbaaababbabaabbaaaba')): | |
| part1 += 1 | |
| print('aaaaabaaabaaabbbaababbaaababbabaabbaaaba:', result) | |
| if (result := validate('bbaabbbaaabbbbbaababababaaababaaabbbabbabbabbababbbbababbabbbabaaabaaaba')): | |
| part1 += 1 | |
| print('bbaabbbaaabbbbbaababababaaababaaabbbabbabbabbababbbbababbabbbabaaabaaaba:', result) | |
| if (result := validate('abbabbbbaabaabaaaaaabaaa')): | |
| part1 += 1 | |
| print('abbabbbbaabaabaaaaaabaaa:', result) | |
| if (result := validate('bbbaababbbbbabaabbaaaaba')): | |
| part1 += 1 | |
| print('bbbaababbbbbabaabbaaaaba:', result) | |
| if (result := validate('aabbabbbbabaaabbaaababbababbbbbb')): | |
| part1 += 1 | |
| print('aabbabbbbabaaabbaaababbababbbbbb:', result) | |
| if (result := validate('bbbbabbbbbbaaabaabbaaaba')): | |
| part1 += 1 | |
| print('bbbbabbbbbbaaabaabbaaaba:', result) | |
| if (result := validate('aaabbabbbbbababbbbaabaabbbbabbaaabbbbbbbabababababbabbbbabbabaabbbbbbababaababaabbbaaabbabbbabba')): | |
| part1 += 1 | |
| print('aaabbabbbbbababbbbaabaabbbbabbaaabbbbbbbabababababbabbbbabbabaabbbbbbababaababaabbbaaabbabbbabba:', result) | |
| if (result := validate('bbbbabababbabaabbaaaaabbbbbabbabaabbabbbababababbabaabab')): | |
| part1 += 1 | |
| print('bbbbabababbabaabbaaaaabbbbbabbabaabbabbbababababbabaabab:', result) | |
| if (result := validate('bbaaaaaabaabaaabaaababaabbbaaabbaababaaabababaabaabaabbaaaabaabb')): | |
| part1 += 1 | |
| print('bbaaaaaabaabaaabaaababaabbbaaabbaababaaabababaabaabaabbaaaabaabb:', result) | |
| if (result := validate('abaaabbabbaaaaaabbbabbabbbbaaaabaababbab')): | |
| part1 += 1 | |
| print('abaaabbabbaaaaaabbbabbabbbbaaaabaababbab:', result) | |
| if (result := validate('bbbaabaaabbaababbbbaabaabbabababababbaab')): | |
| part1 += 1 | |
| print('bbbaabaaabbaababbbbaabaabbabababababbaab:', result) | |
| print('Part 1:', part1) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment